jro_apps/redmine Commit - r5296:aa0d01b3d9f5

Adds an issues visibility level on roles (#7412)....

Jean-Philippe Lang -

r5296:aa0d01b3d9f5

parent child

Context file:

r5296:aa0d01b3d9f5

Collapse all files

db/migrate/20110408103312_add_roles_issues_visibility.rb created 644 +9 0

			@@ -0,0 +1,9
		1	class AddRolesIssuesVisibility < ActiveRecord::Migration
		2	def self.up
		3	add_column :roles, :issues_visibility, :string, :limit => 30, :default => 'default', :null => false
		4	end
		5
		6	def self.down
		7	remove_column :roles, :issues_visibility
		8	end
		9	end

app/controllers/application_controller.rb +6 -2

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

app/controllers/issues_controller.rb +7 -1

              # Redmine - project management software
-             # Copyright (C) 2006-2008  Jean-Philippe Lang
+             # 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, :move, :perform_move, :destroy]
                before_filter :check_project_uniqueness, :only => [:move, :perform_move]
                before_filter :find_project, :only => [:new, :create]
                before_filter :authorize, :except => [:index]
                before_filter :find_optional_project, :only => [:index]
                before_filter :check_for_default_issue_status, :only => [:new, :create]
                before_filter :build_new_issue_from_params, :only => [:new, :create]
                accept_key_auth :index, :show, :create, :update, :destroy
                rescue_from Query::StatementInvalid, :with => :query_statement_invalid
                helper :journals
                helper :projects
                include ProjectsHelper
                helper :custom_fields
                include CustomFieldsHelper
                helper :issue_relations
                include IssueRelationsHelper
                helper :watchers
                include WatchersHelper
                helper :attachments
                include AttachmentsHelper
                helper :queries
                include QueriesHelper
                helper :repositories
                include RepositoriesHelper
                helper :sort
                include SortHelper
                include IssuesHelper
                helper :timelog
                helper :gantt
                include Redmine::Export::PDF
                verify :method => [:post, :delete],
                       :only => :destroy,
                       :render => { :nothing => true, :status => :method_not_allowed }
                verify :method => :post, :only => :create, :render => {:nothing => true, :status => :method_not_allowed }
                verify :method => :post, :only => :bulk_update, :render => {:nothing => true, :status => :method_not_allowed }
                verify :method => :put, :only => :update, :render => {:nothing => true, :status => :method_not_allowed }
                def index
                  retrieve_query
                  sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                  sort_update(@query.sortable_columns)
                  if @query.valid?
                    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.rhtml', :layout => !request.xhr? }
                      format.api
                      format.atom { render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }
                      format.csv  { send_data(issues_to_csv(@issues, @project), :type => 'text/csv; header=present', :filename => 'export.csv') }
                      format.pdf  { send_data(issues_to_pdf(@issues, @project, @query), :type => 'application/pdf', :filename => 'export.pdf') }
                    end
                  else
                    # Send html if the query is not valid
                    render(:template => 'issues/index.rhtml', :layout => !request.xhr?)
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def show
                  @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
                  @journals.each_with_index {|j,i| j.indice = i+1}
                  @journals.reverse! if User.current.wants_comments_in_reverse_order?
                  @changesets = @issue.changesets.visible.all
                  @changesets.reverse! if User.current.wants_comments_in_reverse_order?
                  @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.all
                  @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                  respond_to do |format|
                    format.html { render :template => 'issues/show.rhtml' }
                    format.api
                    format.atom { render :template => 'journals/index', :layout => false, :content_type => 'application/atom+xml' }
                    format.pdf  { send_data(issue_to_pdf(@issue), :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf") }
                  end
                end
                # Add a new issue
                # The new issue will be created from an existing one if copy_from parameter is given
                def new
                  respond_to do |format|
                    format.html { render :action => 'new', :layout => !request.xhr? }
                    format.js { render :partial => 'attributes' }
                  end
                end
                def create
                  call_hook(:controller_issues_new_before_save, { :params => params, :issue => @issue })
                  if @issue.save
                    attachments = Attachment.attach_files(@issue, params[:attachments])
                    render_attachment_warning_if_needed(@issue)
                    flash[:notice] = l(:notice_successful_create)
                    call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})
                    respond_to do |format|
                      format.html {
                        redirect_to(params[:continue] ?  { :action => 'new', :project_id => @project, :issue => {:tracker_id => @issue.tracker, :parent_issue_id => @issue.parent_issue_id}.reject {|k,v| v.nil?} } :
                                    { :action => 'show', :id => @issue })
                      }
                      format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }
                    end
                    return
                  else
                    respond_to do |format|
                      format.html { render :action => 'new' }
                      format.api  { render_validation_errors(@issue) }
                    end
                  end
                end
                def edit
                  update_issue_from_params
                  @journal = @issue.current_journal
                  respond_to do |format|
                    format.html { }
                    format.xml  { }
                  end
                end
                def update
                  update_issue_from_params
                  if @issue.save_issue_with_child_records(params, @time_entry)
                    render_attachment_warning_if_needed(@issue)
                    flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?
                    respond_to do |format|
                      format.html { redirect_back_or_default({:action => 'show', :id => @issue}) }
                      format.api  { head :ok }
                    end
                  else
                    render_attachment_warning_if_needed(@issue)
                    flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?
                    @journal = @issue.current_journal
                    respond_to do |format|
                      format.html { render :action => 'edit' }
                      format.api  { render_validation_errors(@issue) }
                    end
                  end
                end
                # Bulk edit a set of issues
                def bulk_edit
                  @issues.sort!
                  @available_statuses = @projects.map{|p|Workflow.available_statuses(p)}.inject{|memo,w|memo & w}
                  @custom_fields = @projects.map{|p|p.all_issue_custom_fields}.inject{|memo,c|memo & c}
                  @assignables = @projects.map(&:assignable_users).inject{|memo,a| memo & a}
                  @trackers = @projects.map(&:trackers).inject{|memo,t| memo & t}
                end
                def bulk_update
                  @issues.sort!
                  attributes = parse_params_for_bulk_issue_attributes(params)
                  unsaved_issue_ids = []
                  @issues.each do |issue|
                    issue.reload
                    journal = issue.init_journal(User.current, params[:notes])
                    issue.safe_attributes = attributes
                    call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
                    unless issue.save
                      # Keep unsaved issue ids to display them in flash error
                      unsaved_issue_ids << issue.id
                    end
                  end
                  set_flash_from_bulk_issue_save(@issues, unsaved_issue_ids)
                  redirect_back_or_default({:controller => 'issues', :action => 'index', :project_id => @project})
                end
                def destroy
                  @hours = TimeEntry.sum(:hours, :conditions => ['issue_id IN (?)', @issues]).to_f
                  if @hours > 0
                    case params[:todo]
                    when 'destroy'
                      # nothing to do
                    when 'nullify'
                      TimeEntry.update_all('issue_id = NULL', ['issue_id IN (?)', @issues])
                    when 'reassign'
                      reassign_to = @project.issues.find_by_id(params[:reassign_to_id])
                      if reassign_to.nil?
                        flash.now[:error] = l(:error_issue_not_found_in_project)
                        return
                      else
                        TimeEntry.update_all("issue_id = #{reassign_to.id}", ['issue_id IN (?)', @issues])
                      end
                    else
                      # display the destroy form if it's a user request
                      return unless api_request?
                    end
                  end
                  @issues.each 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[:issue] && params[:issue][:project_id]) || params[:project_id]
                  @project = Project.find(project_id)
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Used by #edit and #update to set some common instance variables
                # from the params
                # TODO: Refactor, not everything in here is needed by #edit
                def update_issue_from_params
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                  @priorities = IssuePriority.all
                  @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                  @time_entry = TimeEntry.new(: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.safe_attributes = params[:issue]
                end
                # TODO: Refactor, lots of extra code in here
                # TODO: Changing tracker on an existing issue should not trigger this
                def build_new_issue_from_params
                  if params[:id].blank?
                    @issue = Issue.new
                    @issue.copy_from(params[:copy_from]) if params[:copy_from]
                    @issue.project = @project
                  else
                    @issue = @project.issues.visible.find(params[:id])
                  end
                  @issue.project = @project
                  # Tracker must be set before custom field values
                  @issue.tracker ||= @project.trackers.find((params[:issue] && params[:issue][:tracker_id]) || params[:tracker_id] || :first)
                  if @issue.tracker.nil?
                    render_error l(:error_no_tracker_in_project)
                    return false
                  end
                  @issue.start_date ||= Date.today
                  if params[:issue].is_a?(Hash)
                    @issue.safe_attributes = params[:issue]
                    if User.current.allowed_to?(:add_issue_watchers, @project) && @issue.new_record?
                      @issue.watcher_user_ids = params[:issue]['watcher_user_ids']
                    end
                  end
                  @issue.author = User.current
                  @priorities = IssuePriority.all
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current, true)
                end
                def check_for_default_issue_status
                  if IssueStatus.default.nil?
                    render_error l(:error_no_default_issue_status)
                    return false
                  end
                end
                def parse_params_for_bulk_issue_attributes(params)
                  attributes = (params[:issue] || {}).reject {|k,v| v.blank?}
                  attributes.keys.each {|k| attributes[k] = '' if attributes[k] == 'none'}
                  attributes[:custom_field_values].reject! {|k,v| v.blank?} if attributes[:custom_field_values]
                  attributes
                end
              end

app/models/issue.rb +20 -2

              # 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 Issue < ActiveRecord::Base
                include Redmine::SafeAttributes
                belongs_to :project
                belongs_to :tracker
                belongs_to :status, :class_name => 'IssueStatus', :foreign_key => 'status_id'
                belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'
                belongs_to :assigned_to, :class_name => 'User', :foreign_key => 'assigned_to_id'
                belongs_to :fixed_version, :class_name => 'Version', :foreign_key => 'fixed_version_id'
                belongs_to :priority, :class_name => 'IssuePriority', :foreign_key => 'priority_id'
                belongs_to :category, :class_name => 'IssueCategory', :foreign_key => 'category_id'
                has_many :journals, :as => :journalized, :dependent => :destroy
                has_many :time_entries, :dependent => :delete_all
                has_and_belongs_to_many :changesets, :order => "#{Changeset.table_name}.committed_on ASC, #{Changeset.table_name}.id ASC"
                has_many :relations_from, :class_name => 'IssueRelation', :foreign_key => 'issue_from_id', :dependent => :delete_all
                has_many :relations_to, :class_name => 'IssueRelation', :foreign_key => 'issue_to_id', :dependent => :delete_all
                acts_as_nested_set :scope => 'root_id', :dependent => :destroy
                acts_as_attachable :after_remove => :attachment_removed
                acts_as_customizable
                acts_as_watchable
                acts_as_searchable :columns => ['subject', "#{table_name}.description", "#{Journal.table_name}.notes"],
                                   :include => [:project, :journals],
                                   # sort by id so that limited eager loading doesn't break with postgresql
                                   :order_column => "#{table_name}.id"
                acts_as_event :title => Proc.new {|o| "#{o.tracker.name} ##{o.id} (#{o.status}): #{o.subject}"},
                              :url => Proc.new {|o| {:controller => 'issues', :action => 'show', :id => o.id}},
                              :type => Proc.new {|o| 'issue' + (o.closed? ? ' closed' : '') }
                acts_as_activity_provider :find_options => {:include => [:project, :author, :tracker]},
                                          :author_key => :author_id
                DONE_RATIO_OPTIONS = %w(issue_field issue_status)
                attr_reader :current_journal
                validates_presence_of :subject, :priority, :project, :tracker, :author, :status
                validates_length_of :subject, :maximum => 255
                validates_inclusion_of :done_ratio, :in => 0..100
                validates_numericality_of :estimated_hours, :allow_nil => true
                named_scope :visible, lambda {|*args| { :include => :project,
                                                        :conditions => Issue.visible_condition(args.shift || User.current, *args) } }
                named_scope :open, :conditions => ["#{IssueStatus.table_name}.is_closed = ?", false], :include => :status
                named_scope :recently_updated, :order => "#{Issue.table_name}.updated_on DESC"
                named_scope :with_limit, lambda { |limit| { :limit => limit} }
                named_scope :on_active_project, :include => [:status, :project, :tracker],
                                                :conditions => ["#{Project.table_name}.status=#{Project::STATUS_ACTIVE}"]
                named_scope :without_version, lambda {
                  {
                    :conditions => { :fixed_version_id => nil}
                  }
                }
                named_scope :with_query, lambda {|query|
                  {
                    :conditions => Query.merge_conditions(query.statement)
                  }
                }
                before_create :default_assign
                before_save :close_duplicates, :update_done_ratio_from_issue_status
                after_save :reschedule_following_issues, :update_nested_set_attributes, :update_parent_attributes, :create_journal
                after_destroy :update_parent_attributes
                # Returns a SQL conditions string used to find all issues visible by the specified user
                def self.visible_condition(user, options={})
-                 Project.allowed_to_condition(user, :view_issues, options)
+                 Project.allowed_to_condition(user, :view_issues, options) do |role, user|
+                   case role.issues_visibility
+                   when 'default'
+                     nil
+                   when 'own'
+                     "(#{table_name}.author_id = #{user.id} OR #{table_name}.assigned_to_id = #{user.id})"
+                   else
+                     '1=0'
+                   end
+                 end
                end
                # Returns true if usr or current user is allowed to view the issue
                def visible?(usr=nil)
-                 (usr || User.current).allowed_to?(:view_issues, self.project)
+                 (usr || User.current).allowed_to?(:view_issues, self.project) do |role, user|
+                   case role.issues_visibility
+                   when 'default'
+                     true
+                   when 'own'
+                     self.author == user || self.assigned_to == user
+                   else
+                     false
+                   end
+                 end
                end
                def after_initialize
                  if new_record?
                    # set default values for new records only
                    self.status ||= IssueStatus.default
                    self.priority ||= IssuePriority.default
                  end
                end
                # Overrides Redmine::Acts::Customizable::InstanceMethods#available_custom_fields
                def available_custom_fields
                  (project && tracker) ? (project.all_issue_custom_fields & tracker.custom_fields.all) : []
                end
                def copy_from(arg)
                  issue = arg.is_a?(Issue) ? arg : Issue.visible.find(arg)
                  self.attributes = issue.attributes.dup.except("id", "root_id", "parent_id", "lft", "rgt", "created_on", "updated_on")
                  self.custom_field_values = issue.custom_field_values.inject({}) {|h,v| h[v.custom_field_id] = v.value; h}
                  self.status = issue.status
                  self
                end
                # Moves/copies an issue to a new project and tracker
                # Returns the moved/copied issue on success, false on failure
                def move_to_project(*args)
                  ret = Issue.transaction do
                    move_to_project_without_transaction(*args) || raise(ActiveRecord::Rollback)
                  end || false
                end
                def move_to_project_without_transaction(new_project, new_tracker = nil, options = {})
                  options ||= {}
                  issue = options[:copy] ? self.class.new.copy_from(self) : self
                  if new_project && issue.project_id != new_project.id
                    # delete issue relations
                    unless Setting.cross_project_issue_relations?
                      issue.relations_from.clear
                      issue.relations_to.clear
                    end
                    # issue is moved to another project
                    # reassign to the category with same name if any
                    new_category = issue.category.nil? ? nil : new_project.issue_categories.find_by_name(issue.category.name)
                    issue.category = new_category
                    # Keep the fixed_version if it's still valid in the new_project
                    unless new_project.shared_versions.include?(issue.fixed_version)
                      issue.fixed_version = nil
                    end
                    issue.project = new_project
                    if issue.parent && issue.parent.project_id != issue.project_id
                      issue.parent_issue_id = nil
                    end
                  end
                  if new_tracker
                    issue.tracker = new_tracker
                    issue.reset_custom_values!
                  end
                  if options[:copy]
                    issue.custom_field_values = self.custom_field_values.inject({}) {|h,v| h[v.custom_field_id] = v.value; h}
                    issue.status = if options[:attributes] && options[:attributes][:status_id]
                                     IssueStatus.find_by_id(options[:attributes][:status_id])
                                   else
                                     self.status
                                   end
                  end
                  # Allow bulk setting of attributes on the issue
                  if options[:attributes]
                    issue.attributes = options[:attributes]
                  end
                  if issue.save
                    unless options[:copy]
                      # Manually update project_id on related time entries
                      TimeEntry.update_all("project_id = #{new_project.id}", {:issue_id => id})
                      issue.children.each do |child|
                        unless child.move_to_project_without_transaction(new_project)
                          # Move failed and transaction was rollback'd
                          return false
                        end
                      end
                    end
                  else
                    return false
                  end
                  issue
                end
                def status_id=(sid)
                  self.status = nil
                  write_attribute(:status_id, sid)
                end
                def priority_id=(pid)
                  self.priority = nil
                  write_attribute(:priority_id, pid)
                end
                def tracker_id=(tid)
                  self.tracker = nil
                  result = write_attribute(:tracker_id, tid)
                  @custom_field_values = nil
                  result
                end
                # Overrides attributes= so that tracker_id gets assigned first
                def attributes_with_tracker_first=(new_attributes, *args)
                  return if new_attributes.nil?
                  new_tracker_id = new_attributes['tracker_id'] || new_attributes[:tracker_id]
                  if new_tracker_id
                    self.tracker_id = new_tracker_id
                  end
                  send :attributes_without_tracker_first=, new_attributes, *args
                end
                # Do not redefine alias chain on reload (see #4838)
                alias_method_chain(:attributes=, :tracker_first) unless method_defined?(:attributes_without_tracker_first=)
                def estimated_hours=(h)
                  write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h)
                end
                safe_attributes 'tracker_id',
                  'status_id',
                  'parent_issue_id',
                  'category_id',
                  'assigned_to_id',
                  'priority_id',
                  'fixed_version_id',
                  'subject',
                  'description',
                  'start_date',
                  'due_date',
                  'done_ratio',
                  'estimated_hours',
                  'custom_field_values',
                  'custom_fields',
                  'lock_version',
                  :if => lambda {|issue, user| issue.new_record? || user.allowed_to?(:edit_issues, issue.project) }
                safe_attributes 'status_id',
                  'assigned_to_id',
                  'fixed_version_id',
                  'done_ratio',
                  :if => lambda {|issue, user| issue.new_statuses_allowed_to(user).any? }
                # Safely sets attributes
                # Should be called from controllers instead of #attributes=
                # attr_accessible is too rough because we still want things like
                # Issue.new(:project => foo) to work
                # TODO: move workflow/permission checks from controllers to here
                def safe_attributes=(attrs, user=User.current)
                  return unless attrs.is_a?(Hash)
                  # User can change issue attributes only if he has :edit permission or if a workflow transition is allowed
                  attrs = delete_unsafe_attributes(attrs, user)
                  return if attrs.empty?
                  # Tracker must be set before since new_statuses_allowed_to depends on it.
                  if t = attrs.delete('tracker_id')
                    self.tracker_id = t
                  end
                  if attrs['status_id']
                    unless new_statuses_allowed_to(user).collect(&:id).include?(attrs['status_id'].to_i)
                      attrs.delete('status_id')
                    end
                  end
                  unless leaf?
                    attrs.reject! {|k,v| %w(priority_id done_ratio start_date due_date estimated_hours).include?(k)}
                  end
                  if attrs.has_key?('parent_issue_id')
                    if !user.allowed_to?(:manage_subtasks, project)
                      attrs.delete('parent_issue_id')
                    elsif !attrs['parent_issue_id'].blank?
                      attrs.delete('parent_issue_id') unless Issue.visible(user).exists?(attrs['parent_issue_id'].to_i)
                    end
                  end
                  self.attributes = attrs
                end
                def done_ratio
                  if Issue.use_status_for_done_ratio? && status && status.default_done_ratio
                    status.default_done_ratio
                  else
                    read_attribute(:done_ratio)
                  end
                end
                def self.use_status_for_done_ratio?
                  Setting.issue_done_ratio == 'issue_status'
                end
                def self.use_field_for_done_ratio?
                  Setting.issue_done_ratio == 'issue_field'
                end
                def validate
                  if self.due_date.nil? && @attributes['due_date'] && !@attributes['due_date'].empty?
                    errors.add :due_date, :not_a_date
                  end
                  if self.due_date and self.start_date and self.due_date < self.start_date
                    errors.add :due_date, :greater_than_start_date
                  end
                  if start_date && soonest_start && start_date < soonest_start
                    errors.add :start_date, :invalid
                  end
                  if fixed_version
                    if !assignable_versions.include?(fixed_version)
                      errors.add :fixed_version_id, :inclusion
                    elsif reopened? && fixed_version.closed?
                      errors.add_to_base I18n.t(:error_can_not_reopen_issue_on_closed_version)
                    end
                  end
                  # Checks that the issue can not be added/moved to a disabled tracker
                  if project && (tracker_id_changed? || project_id_changed?)
                    unless project.trackers.include?(tracker)
                      errors.add :tracker_id, :inclusion
                    end
                  end
                  # Checks parent issue assignment
                  if @parent_issue
                    if @parent_issue.project_id != project_id
                      errors.add :parent_issue_id, :not_same_project
                    elsif !new_record?
                      # moving an existing issue
                      if @parent_issue.root_id != root_id
                        # we can always move to another tree
                      elsif move_possible?(@parent_issue)
                        # move accepted inside tree
                      else
                        errors.add :parent_issue_id, :not_a_valid_parent
                      end
                    end
                  end
                end
                # Set the done_ratio using the status if that setting is set.  This will keep the done_ratios
                # even if the user turns off the setting later
                def update_done_ratio_from_issue_status
                  if Issue.use_status_for_done_ratio? && status && status.default_done_ratio
                    self.done_ratio = status.default_done_ratio
                  end
                end
                def init_journal(user, notes = "")
                  @current_journal ||= Journal.new(:journalized => self, :user => user, :notes => notes)
                  @issue_before_change = self.clone
                  @issue_before_change.status = self.status
                  @custom_values_before_change = {}
                  self.custom_values.each {|c| @custom_values_before_change.store c.custom_field_id, c.value }
                  # Make sure updated_on is updated when adding a note.
                  updated_on_will_change!
                  @current_journal
                end
                # Return true if the issue is closed, otherwise false
                def closed?
                  self.status.is_closed?
                end
                # Return true if the issue is being reopened
                def reopened?
                  if !new_record? && status_id_changed?
                    status_was = IssueStatus.find_by_id(status_id_was)
                    status_new = IssueStatus.find_by_id(status_id)
                    if status_was && status_new && status_was.is_closed? && !status_new.is_closed?
                      return true
                    end
                  end
                  false
                end
                # Return true if the issue is being closed
                def closing?
                  if !new_record? && status_id_changed?
                    status_was = IssueStatus.find_by_id(status_id_was)
                    status_new = IssueStatus.find_by_id(status_id)
                    if status_was && status_new && !status_was.is_closed? && status_new.is_closed?
                      return true
                    end
                  end
                  false
                end
                # Returns true if the issue is overdue
                def overdue?
                  !due_date.nil? && (due_date < Date.today) && !status.is_closed?
                end
                # Is the amount of work done less than it should for the due date
                def behind_schedule?
                  return false if start_date.nil? || due_date.nil?
                  done_date = start_date + ((due_date - start_date+1)* done_ratio/100).floor
                  return done_date <= Date.today
                end
                # Does this issue have children?
                def children?
                  !leaf?
                end
                # Users the issue can be assigned to
                def assignable_users
                  users = project.assignable_users
                  users << author if author
                  users.uniq.sort
                end
                # Versions that the issue can be assigned to
                def assignable_versions
                  @assignable_versions ||= (project.shared_versions.open + [Version.find_by_id(fixed_version_id_was)]).compact.uniq.sort
                end
                # Returns true if this issue is blocked by another issue that is still open
                def blocked?
                  !relations_to.detect {|ir| ir.relation_type == 'blocks' && !ir.issue_from.closed?}.nil?
                end
                # Returns an array of status that user is able to apply
                def new_statuses_allowed_to(user, include_default=false)
                  statuses = status.find_new_statuses_allowed_to(
                    user.roles_for_project(project),
                    tracker,
                    author == user,
                    assigned_to_id_changed? ? assigned_to_id_was == user.id : assigned_to_id == user.id
                    )
                  statuses << status unless statuses.empty?
                  statuses << IssueStatus.default if include_default
                  statuses = statuses.uniq.sort
                  blocked? ? statuses.reject {|s| s.is_closed?} : statuses
                end
                # Returns the mail adresses of users that should be notified
                def recipients
                  notified = project.notified_users
                  # Author and assignee are always notified unless they have been
                  # locked or don't want to be notified
                  notified << author if author && author.active? && author.notify_about?(self)
                  notified << assigned_to if assigned_to && assigned_to.active? && assigned_to.notify_about?(self)
                  notified.uniq!
                  # Remove users that can not view the issue
                  notified.reject! {|user| !visible?(user)}
                  notified.collect(&:mail)
                end
                # Returns the total number of hours spent on this issue and its descendants
                #
                # Example:
                #   spent_hours => 0.0
                #   spent_hours => 50.2
                def spent_hours
                  @spent_hours ||= self_and_descendants.sum("#{TimeEntry.table_name}.hours", :include => :time_entries).to_f || 0.0
                end
                def relations
                  (relations_from + relations_to).sort
                end
                def all_dependent_issues(except=[])
                  except << self
                  dependencies = []
                  relations_from.each do |relation|
                    if relation.issue_to && !except.include?(relation.issue_to)
                      dependencies << relation.issue_to
                      dependencies += relation.issue_to.all_dependent_issues(except)
                    end
                  end
                  dependencies
                end
                # Returns an array of issues that duplicate this one
                def duplicates
                  relations_to.select {|r| r.relation_type == IssueRelation::TYPE_DUPLICATES}.collect {|r| r.issue_from}
                end
                # Returns the due date or the target due date if any
                # Used on gantt chart
                def due_before
                  due_date || (fixed_version ? fixed_version.effective_date : nil)
                end
                # Returns the time scheduled for this issue.
                #
                # Example:
                #   Start Date: 2/26/09, End Date: 3/04/09
                #   duration => 6
                def duration
                  (start_date && due_date) ? due_date - start_date : 0
                end
                def soonest_start
                  @soonest_start ||= (
                      relations_to.collect{|relation| relation.successor_soonest_start} +
                      ancestors.collect(&:soonest_start)
                    ).compact.max
                end
                def reschedule_after(date)
                  return if date.nil?
                  if leaf?
                    if start_date.nil? || start_date < date
                      self.start_date, self.due_date = date, date + duration
                      save
                    end
                  else
                    leaves.each do |leaf|
                      leaf.reschedule_after(date)
                    end
                  end
                end
                def <=>(issue)
                  if issue.nil?
                    -1
                  elsif root_id != issue.root_id
                    (root_id || 0) <=> (issue.root_id || 0)
                  else
                    (lft || 0) <=> (issue.lft || 0)
                  end
                end
                def to_s
                  "#{tracker} ##{id}: #{subject}"
                end
                # Returns a string of css classes that apply to the issue
                def css_classes
                  s = "issue status-#{status.position} priority-#{priority.position}"
                  s << ' closed' if closed?
                  s << ' overdue' if overdue?
                  s << ' child' if child?
                  s << ' parent' unless leaf?
                  s << ' created-by-me' if User.current.logged? && author_id == User.current.id
                  s << ' assigned-to-me' if User.current.logged? && assigned_to_id == User.current.id
                  s
                end
                # Saves an issue, time_entry, attachments, and a journal from the parameters
                # Returns false if save fails
                def save_issue_with_child_records(params, existing_time_entry=nil)
                  Issue.transaction do
                    if params[:time_entry] && (params[:time_entry][:hours].present? || params[:time_entry][:comments].present?) && User.current.allowed_to?(:log_time, project)
                      @time_entry = existing_time_entry || TimeEntry.new
                      @time_entry.project = project
                      @time_entry.issue = self
                      @time_entry.user = User.current
                      @time_entry.spent_on = Date.today
                      @time_entry.attributes = params[:time_entry]
                      self.time_entries << @time_entry
                    end
                    if valid?
                      attachments = Attachment.attach_files(self, params[:attachments])
                      attachments[:files].each {|a| @current_journal.details << JournalDetail.new(:property => 'attachment', :prop_key => a.id, :value => a.filename)}
                      # TODO: Rename hook
                      Redmine::Hook.call_hook(:controller_issues_edit_before_save, { :params => params, :issue => self, :time_entry => @time_entry, :journal => @current_journal})
                      begin
                        if save
                          # TODO: Rename hook
                          Redmine::Hook.call_hook(:controller_issues_edit_after_save, { :params => params, :issue => self, :time_entry => @time_entry, :journal => @current_journal})
                        else
                          raise ActiveRecord::Rollback
                        end
                      rescue ActiveRecord::StaleObjectError
                        attachments[:files].each(&:destroy)
                        errors.add_to_base l(:notice_locking_conflict)
                        raise ActiveRecord::Rollback
                      end
                    end
                  end
                end
                # Unassigns issues from +version+ if it's no longer shared with issue's project
                def self.update_versions_from_sharing_change(version)
                  # Update issues assigned to the version
                  update_versions(["#{Issue.table_name}.fixed_version_id = ?", version.id])
                end
                # Unassigns issues from versions that are no longer shared
                # after +project+ was moved
                def self.update_versions_from_hierarchy_change(project)
                  moved_project_ids = project.self_and_descendants.reload.collect(&:id)
                  # Update issues of the moved projects and issues assigned to a version of a moved project
                  Issue.update_versions(["#{Version.table_name}.project_id IN (?) OR #{Issue.table_name}.project_id IN (?)", moved_project_ids, moved_project_ids])
                end
                def parent_issue_id=(arg)
                  parent_issue_id = arg.blank? ? nil : arg.to_i
                  if parent_issue_id && @parent_issue = Issue.find_by_id(parent_issue_id)
                    @parent_issue.id
                  else
                    @parent_issue = nil
                    nil
                  end
                end
                def parent_issue_id
                  if instance_variable_defined? :@parent_issue
                    @parent_issue.nil? ? nil : @parent_issue.id
                  else
                    parent_id
                  end
                end
                # Extracted from the ReportsController.
                def self.by_tracker(project)
                  count_and_group_by(:project => project,
                                     :field => 'tracker_id',
                                     :joins => Tracker.table_name)
                end
                def self.by_version(project)
                  count_and_group_by(:project => project,
                                     :field => 'fixed_version_id',
                                     :joins => Version.table_name)
                end
                def self.by_priority(project)
                  count_and_group_by(:project => project,
                                     :field => 'priority_id',
                                     :joins => IssuePriority.table_name)
                end
                def self.by_category(project)
                  count_and_group_by(:project => project,
                                     :field => 'category_id',
                                     :joins => IssueCategory.table_name)
                end
                def self.by_assigned_to(project)
                  count_and_group_by(:project => project,
                                     :field => 'assigned_to_id',
                                     :joins => User.table_name)
                end
                def self.by_author(project)
                  count_and_group_by(:project => project,
                                     :field => 'author_id',
                                     :joins => User.table_name)
                end
                def self.by_subproject(project)
                  ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                              s.is_closed as closed,
                                                              #{Issue.table_name}.project_id as project_id,
                                                              count(#{Issue.table_name}.id) as total
                                                            from
                                                              #{Issue.table_name}, #{Project.table_name}, #{IssueStatus.table_name} s
                                                            where
                                                              #{Issue.table_name}.status_id=s.id
                                                              and #{Issue.table_name}.project_id = #{Project.table_name}.id
                                                              and #{visible_condition(User.current, :project => project, :with_subprojects => true)}
                                                              and #{Issue.table_name}.project_id <> #{project.id}
                                                            group by s.id, s.is_closed, #{Issue.table_name}.project_id") if project.descendants.active.any?
                end
                # End ReportsController extraction
                # Returns an array of projects that current user can move issues to
                def self.allowed_target_projects_on_move
                  projects = []
                  if User.current.admin?
                    # admin is allowed to move issues to any active (visible) project
                    projects = Project.visible.all
                  elsif User.current.logged?
                    if Role.non_member.allowed_to?(:move_issues)
                      projects = Project.visible.all
                    else
                      User.current.memberships.each {|m| projects << m.project if m.roles.detect {|r| r.allowed_to?(:move_issues)}}
                    end
                  end
                  projects
                end
                private
                def update_nested_set_attributes
                  if root_id.nil?
                    # issue was just created
                    self.root_id = (@parent_issue.nil? ? id : @parent_issue.root_id)
                    set_default_left_and_right
                    Issue.update_all("root_id = #{root_id}, lft = #{lft}, rgt = #{rgt}", ["id = ?", id])
                    if @parent_issue
                      move_to_child_of(@parent_issue)
                    end
                    reload
                  elsif parent_issue_id != parent_id
                    former_parent_id = parent_id
                    # moving an existing issue
                    if @parent_issue && @parent_issue.root_id == root_id
                      # inside the same tree
                      move_to_child_of(@parent_issue)
                    else
                      # to another tree
                      unless root?
                        move_to_right_of(root)
                        reload
                      end
                      old_root_id = root_id
                      self.root_id = (@parent_issue.nil? ? id : @parent_issue.root_id )
                      target_maxright = nested_set_scope.maximum(right_column_name) || 0
                      offset = target_maxright + 1 - lft
                      Issue.update_all("root_id = #{root_id}, lft = lft + #{offset}, rgt = rgt + #{offset}",
                                        ["root_id = ? AND lft >= ? AND rgt <= ? ", old_root_id, lft, rgt])
                      self[left_column_name] = lft + offset
                      self[right_column_name] = rgt + offset
                      if @parent_issue
                        move_to_child_of(@parent_issue)
                      end
                    end
                    reload
                    # delete invalid relations of all descendants
                    self_and_descendants.each do |issue|
                      issue.relations.each do |relation|
                        relation.destroy unless relation.valid?
                      end
                    end
                    # update former parent
                    recalculate_attributes_for(former_parent_id) if former_parent_id
                  end
                  remove_instance_variable(:@parent_issue) if instance_variable_defined?(:@parent_issue)
                end
                def update_parent_attributes
                  recalculate_attributes_for(parent_id) if parent_id
                end
                def recalculate_attributes_for(issue_id)
                  if issue_id && p = Issue.find_by_id(issue_id)
                    # priority = highest priority of children
                    if priority_position = p.children.maximum("#{IssuePriority.table_name}.position", :include => :priority)
                      p.priority = IssuePriority.find_by_position(priority_position)
                    end
                    # start/due dates = lowest/highest dates of children
                    p.start_date = p.children.minimum(:start_date)
                    p.due_date = p.children.maximum(:due_date)
                    if p.start_date && p.due_date && p.due_date < p.start_date
                      p.start_date, p.due_date = p.due_date, p.start_date
                    end
                    # done ratio = weighted average ratio of leaves
                    unless Issue.use_status_for_done_ratio? && p.status && p.status.default_done_ratio
                      leaves_count = p.leaves.count
                      if leaves_count > 0
                        average = p.leaves.average(:estimated_hours).to_f
                        if average == 0
                          average = 1
                        end
                        done = p.leaves.sum("COALESCE(estimated_hours, #{average}) * (CASE WHEN is_closed = #{connection.quoted_true} THEN 100 ELSE COALESCE(done_ratio, 0) END)", :include => :status).to_f
                        progress = done / (average * leaves_count)
                        p.done_ratio = progress.round
                      end
                    end
                    # estimate = sum of leaves estimates
                    p.estimated_hours = p.leaves.sum(:estimated_hours).to_f
                    p.estimated_hours = nil if p.estimated_hours == 0.0
                    # ancestors will be recursively updated
                    p.save(false)
                  end
                end
                # Update issues so their versions are not pointing to a
                # fixed_version that is not shared with the issue's project
                def self.update_versions(conditions=nil)
                  # Only need to update issues with a fixed_version from
                  # a different project and that is not systemwide shared
                  Issue.all(:conditions => merge_conditions("#{Issue.table_name}.fixed_version_id IS NOT NULL" +
                                                              " AND #{Issue.table_name}.project_id <> #{Version.table_name}.project_id" +
                                                              " AND #{Version.table_name}.sharing <> 'system'",
                                                              conditions),
                            :include => [:project, :fixed_version]
                            ).each do |issue|
                    next if issue.project.nil? || issue.fixed_version.nil?
                    unless issue.project.shared_versions.include?(issue.fixed_version)
                      issue.init_journal(User.current)
                      issue.fixed_version = nil
                      issue.save
                    end
                  end
                end
                # Callback on attachment deletion
                def attachment_removed(obj)
                  journal = init_journal(User.current)
                  journal.details << JournalDetail.new(:property => 'attachment',
                                                       :prop_key => obj.id,
                                                       :old_value => obj.filename)
                  journal.save
                end
                # Default assignment based on category
                def default_assign
                  if assigned_to.nil? && category && category.assigned_to
                    self.assigned_to = category.assigned_to
                  end
                end
                # Updates start/due dates of following issues
                def reschedule_following_issues
                  if start_date_changed? || due_date_changed?
                    relations_from.each do |relation|
                      relation.set_issue_to_dates
                    end
                  end
                end
                # Closes duplicates if the issue is being closed
                def close_duplicates
                  if closing?
                    duplicates.each do |duplicate|
                      # Reload is need in case the duplicate was updated by a previous duplicate
                      duplicate.reload
                      # Don't re-close it if it's already closed
                      next if duplicate.closed?
                      # Same user and notes
                      if @current_journal
                        duplicate.init_journal(@current_journal.user, @current_journal.notes)
                      end
                      duplicate.update_attribute :status, self.status
                    end
                  end
                end
                # Saves the changes in a Journal
                # Called after_save
                def create_journal
                  if @current_journal
                    # attributes changes
                    (Issue.column_names - %w(id root_id lft rgt lock_version created_on updated_on)).each {|c|
                      @current_journal.details << JournalDetail.new(:property => 'attr',
                                                                    :prop_key => c,
                                                                    :old_value => @issue_before_change.send(c),
                                                                    :value => send(c)) unless send(c)==@issue_before_change.send(c)
                    }
                    # custom fields changes
                    custom_values.each {|c|
                      next if (@custom_values_before_change[c.custom_field_id]==c.value ||
                                (@custom_values_before_change[c.custom_field_id].blank? && c.value.blank?))
                      @current_journal.details << JournalDetail.new(:property => 'cf',
                                                                    :prop_key => c.custom_field_id,
                                                                    :old_value => @custom_values_before_change[c.custom_field_id],
                                                                    :value => c.value)
                    }
                    @current_journal.save
                    # reset current journal
                    init_journal @current_journal.user, @current_journal.notes
                  end
                end
                # Query generator for selecting groups of issue counts for a project
                # based on specific criteria
                #
                # Options
                # * project - Project to search in.
                # * field - String. Issue field to key off of in the grouping.
                # * joins - String. The table name to join against.
                def self.count_and_group_by(options)
                  project = options.delete(:project)
                  select_field = options.delete(:field)
                  joins = options.delete(:joins)
                  where = "#{Issue.table_name}.#{select_field}=j.id"
                  ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                              s.is_closed as closed,
                                                              j.id as #{select_field},
                                                              count(#{Issue.table_name}.id) as total
                                                            from
                                                                #{Issue.table_name}, #{Project.table_name}, #{IssueStatus.table_name} s, #{joins} j
                                                            where
                                                              #{Issue.table_name}.status_id=s.id
                                                              and #{where}
                                                              and #{Issue.table_name}.project_id=#{Project.table_name}.id
                                                              and #{visible_condition(User.current, :project => project)}
                                                            group by s.id, s.is_closed, j.id")
                end
              end

app/models/project.rb +7 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 Project < ActiveRecord::Base
                include Redmine::SafeAttributes
                # Project statuses
                STATUS_ACTIVE     = 1
                STATUS_ARCHIVED   = 9
                # Maximum length for project identifiers
                IDENTIFIER_MAX_LENGTH = 100
                # Specific overidden Activities
                has_many :time_entry_activities
                has_many :members, :include => [:user, :roles], :conditions => "#{User.table_name}.type='User' AND #{User.table_name}.status=#{User::STATUS_ACTIVE}"
                has_many :memberships, :class_name => 'Member'
                has_many :member_principals, :class_name => 'Member',
                                             :include => :principal,
                                             :conditions => "#{Principal.table_name}.type='Group' OR (#{Principal.table_name}.type='User' AND #{Principal.table_name}.status=#{User::STATUS_ACTIVE})"
                has_many :users, :through => :members
                has_many :principals, :through => :member_principals, :source => :principal
                has_many :enabled_modules, :dependent => :delete_all
                has_and_belongs_to_many :trackers, :order => "#{Tracker.table_name}.position"
                has_many :issues, :dependent => :destroy, :order => "#{Issue.table_name}.created_on DESC", :include => [:status, :tracker]
                has_many :issue_changes, :through => :issues, :source => :journals
                has_many :versions, :dependent => :destroy, :order => "#{Version.table_name}.effective_date DESC, #{Version.table_name}.name DESC"
                has_many :time_entries, :dependent => :delete_all
                has_many :queries, :dependent => :delete_all
                has_many :documents, :dependent => :destroy
                has_many :news, :dependent => :destroy, :include => :author
                has_many :issue_categories, :dependent => :delete_all, :order => "#{IssueCategory.table_name}.name"
                has_many :boards, :dependent => :destroy, :order => "position ASC"
                has_one :repository, :dependent => :destroy
                has_many :changesets, :through => :repository
                has_one :wiki, :dependent => :destroy
                # Custom field for the project issues
                has_and_belongs_to_many :issue_custom_fields,
                                        :class_name => 'IssueCustomField',
                                        :order => "#{CustomField.table_name}.position",
                                        :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}",
                                        :association_foreign_key => 'custom_field_id'
                acts_as_nested_set :order => 'name', :dependent => :destroy
                acts_as_attachable :view_permission => :view_files,
                                   :delete_permission => :manage_files
                acts_as_customizable
                acts_as_searchable :columns => ['name', 'identifier', 'description'], :project_key => 'id', :permission => nil
                acts_as_event :title => Proc.new {|o| "#{l(:label_project)}: #{o.name}"},
                              :url => Proc.new {|o| {:controller => 'projects', :action => 'show', :id => o}},
                              :author => nil
                attr_protected :status
                validates_presence_of :name, :identifier
                validates_uniqueness_of :identifier
                validates_associated :repository, :wiki
                validates_length_of :name, :maximum => 255
                validates_length_of :homepage, :maximum => 255
                validates_length_of :identifier, :in => 1..IDENTIFIER_MAX_LENGTH
                # donwcase letters, digits, dashes but not digits only
                validates_format_of :identifier, :with => /^(?!\d+$)[a-z0-9\-]*$/, :if => Proc.new { |p| p.identifier_changed? }
                # reserved words
                validates_exclusion_of :identifier, :in => %w( new )
                before_destroy :delete_all_members
                named_scope :has_module, lambda { |mod| { :conditions => ["#{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name=?)", mod.to_s] } }
                named_scope :active, { :conditions => "#{Project.table_name}.status = #{STATUS_ACTIVE}"}
                named_scope :all_public, { :conditions => { :is_public => true } }
                named_scope :visible, lambda {|*args| {:conditions => Project.visible_condition(args.shift || User.current, *args) }}
                def initialize(attributes = nil)
                  super
                  initialized = (attributes || {}).stringify_keys
                  if !initialized.key?('identifier') && Setting.sequential_project_identifiers?
                    self.identifier = Project.next_identifier
                  end
                  if !initialized.key?('is_public')
                    self.is_public = Setting.default_projects_public?
                  end
                  if !initialized.key?('enabled_module_names')
                    self.enabled_module_names = Setting.default_projects_modules
                  end
                  if !initialized.key?('trackers') && !initialized.key?('tracker_ids')
                    self.trackers = Tracker.all
                  end
                end
                def identifier=(identifier)
                  super unless identifier_frozen?
                end
                def identifier_frozen?
                  errors[:identifier].nil? && !(new_record? || identifier.blank?)
                end
                # returns latest created projects
                # non public projects will be returned only if user is a member of those
                def self.latest(user=nil, count=5)
                  visible(user).find(:all, :limit => count, :order => "created_on DESC")
                end
                def self.visible_by(user=nil)
                  ActiveSupport::Deprecation.warn "Project.visible_by is deprecated and will be removed in Redmine 1.3.0. Use Project.visible_condition instead."
                  visible_condition(user || User.current)
                end
                # Returns a SQL conditions string used to find all projects visible by the specified user.
                #
                # Examples:
                #   Project.visible_condition(admin)        => "projects.status = 1"
                #   Project.visible_condition(normal_user)  => "((projects.status = 1) AND (projects.is_public = 1 OR projects.id IN (1,3,4)))"
                #   Project.visible_condition(anonymous)    => "((projects.status = 1) AND (projects.is_public = 1))"
                def self.visible_condition(user, options={})
                  allowed_to_condition(user, :view_project, options)
                end
                # Returns a SQL conditions string used to find all projects for which +user+ has the given +permission+
                #
                # Valid options:
                # * :project => limit the condition to project
                # * :with_subprojects => limit the condition to project and its subprojects
                # * :member => limit the condition to the user projects
                def self.allowed_to_condition(user, permission, options={})
                  base_statement = "#{Project.table_name}.status=#{Project::STATUS_ACTIVE}"
                  if perm = Redmine::AccessControl.permission(permission)
                    unless perm.project_module.nil?
                      # If the permission belongs to a project module, make sure the module is enabled
                      base_statement << " AND #{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name='#{perm.project_module}')"
                    end
                  end
                  if options[:project]
                    project_statement = "#{Project.table_name}.id = #{options[:project].id}"
                    project_statement << " OR (#{Project.table_name}.lft > #{options[:project].lft} AND #{Project.table_name}.rgt < #{options[:project].rgt})" if options[:with_subprojects]
                    base_statement = "(#{project_statement}) AND (#{base_statement})"
                  end
                  if user.admin?
                    base_statement
                  else
                    statement_by_role = {}
                    if user.logged?
                      if Role.non_member.allowed_to?(permission) && !options[:member]
                        statement_by_role[Role.non_member] = "#{Project.table_name}.is_public = #{connection.quoted_true}"
                      end
                      user.projects_by_role.each do |role, projects|
                        if role.allowed_to?(permission)
                          statement_by_role[role] = "#{Project.table_name}.id IN (#{projects.collect(&:id).join(',')})"
                        end
                      end
                    else
                      if Role.anonymous.allowed_to?(permission) && !options[:member]
                        statement_by_role[Role.anonymous] = "#{Project.table_name}.is_public = #{connection.quoted_true}"
                      end
                    end
                    if statement_by_role.empty?
                      "1=0"
                    else
+                     if block_given?
+                       statement_by_role.each do |role, statement|
+                         if s = yield(role, user)
+                           statement_by_role[role] = "(#{statement} AND (#{s}))"
+                         end
+                       end
+                     end
                      "((#{base_statement}) AND (#{statement_by_role.values.join(' OR ')}))"
                    end
                  end
                end
                # Returns the Systemwide and project specific activities
                def activities(include_inactive=false)
                  if include_inactive
                    return all_activities
                  else
                    return active_activities
                  end
                end
                # Will create a new Project specific Activity or update an existing one
                #
                # This will raise a ActiveRecord::Rollback if the TimeEntryActivity
                # does not successfully save.
                def update_or_create_time_entry_activity(id, activity_hash)
                  if activity_hash.respond_to?(:has_key?) && activity_hash.has_key?('parent_id')
                    self.create_time_entry_activity_if_needed(activity_hash)
                  else
                    activity = project.time_entry_activities.find_by_id(id.to_i)
                    activity.update_attributes(activity_hash) if activity
                  end
                end
                # Create a new TimeEntryActivity if it overrides a system TimeEntryActivity
                #
                # This will raise a ActiveRecord::Rollback if the TimeEntryActivity
                # does not successfully save.
                def create_time_entry_activity_if_needed(activity)
                  if activity['parent_id']
                    parent_activity = TimeEntryActivity.find(activity['parent_id'])
                    activity['name'] = parent_activity.name
                    activity['position'] = parent_activity.position
                    if Enumeration.overridding_change?(activity, parent_activity)
                      project_activity = self.time_entry_activities.create(activity)
                      if project_activity.new_record?
                        raise ActiveRecord::Rollback, "Overridding TimeEntryActivity was not successfully saved"
                      else
                        self.time_entries.update_all("activity_id = #{project_activity.id}", ["activity_id = ?", parent_activity.id])
                      end
                    end
                  end
                end
                # Returns a :conditions SQL string that can be used to find the issues associated with this project.
                #
                # Examples:
                #   project.project_condition(true)  => "(projects.id = 1 OR (projects.lft > 1 AND projects.rgt < 10))"
                #   project.project_condition(false) => "projects.id = 1"
                def project_condition(with_subprojects)
                  cond = "#{Project.table_name}.id = #{id}"
                  cond = "(#{cond} OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt}))" if with_subprojects
                  cond
                end
                def self.find(*args)
                  if args.first && args.first.is_a?(String) && !args.first.match(/^\d*$/)
                    project = find_by_identifier(*args)
                    raise ActiveRecord::RecordNotFound, "Couldn't find Project with identifier=#{args.first}" if project.nil?
                    project
                  else
                    super
                  end
                end
                def to_param
                  # id is used for projects with a numeric identifier (compatibility)
                  @to_param ||= (identifier.to_s =~ %r{^\d*$} ? id : identifier)
                end
                def active?
                  self.status == STATUS_ACTIVE
                end
                def archived?
                  self.status == STATUS_ARCHIVED
                end
                # Archives the project and its descendants
                def archive
                  # Check that there is no issue of a non descendant project that is assigned
                  # to one of the project or descendant versions
                  v_ids = self_and_descendants.collect {|p| p.version_ids}.flatten
                  if v_ids.any? && Issue.find(:first, :include => :project,
                                                      :conditions => ["(#{Project.table_name}.lft < ? OR #{Project.table_name}.rgt > ?)" +
                                                                      " AND #{Issue.table_name}.fixed_version_id IN (?)", lft, rgt, v_ids])
                    return false
                  end
                  Project.transaction do
                    archive!
                  end
                  true
                end
                # Unarchives the project
                # All its ancestors must be active
                def unarchive
                  return false if ancestors.detect {|a| !a.active?}
                  update_attribute :status, STATUS_ACTIVE
                end
                # Returns an array of projects the project can be moved to
                # by the current user
                def allowed_parents
                  return @allowed_parents if @allowed_parents
                  @allowed_parents = Project.find(:all, :conditions => Project.allowed_to_condition(User.current, :add_subprojects))
                  @allowed_parents = @allowed_parents - self_and_descendants
                  if User.current.allowed_to?(:add_project, nil, :global => true) || (!new_record? && parent.nil?)
                    @allowed_parents << nil
                  end
                  unless parent.nil? || @allowed_parents.empty? || @allowed_parents.include?(parent)
                    @allowed_parents << parent
                  end
                  @allowed_parents
                end
                # Sets the parent of the project with authorization check
                def set_allowed_parent!(p)
                  unless p.nil? || p.is_a?(Project)
                    if p.to_s.blank?
                      p = nil
                    else
                      p = Project.find_by_id(p)
                      return false unless p
                    end
                  end
                  if p.nil?
                    if !new_record? && allowed_parents.empty?
                      return false
                    end
                  elsif !allowed_parents.include?(p)
                    return false
                  end
                  set_parent!(p)
                end
                # Sets the parent of the project
                # Argument can be either a Project, a String, a Fixnum or nil
                def set_parent!(p)
                  unless p.nil? || p.is_a?(Project)
                    if p.to_s.blank?
                      p = nil
                    else
                      p = Project.find_by_id(p)
                      return false unless p
                    end
                  end
                  if p == parent && !p.nil?
                    # Nothing to do
                    true
                  elsif p.nil? || (p.active? && move_possible?(p))
                    # Insert the project so that target's children or root projects stay alphabetically sorted
                    sibs = (p.nil? ? self.class.roots : p.children)
                    to_be_inserted_before = sibs.detect {|c| c.name.to_s.downcase > name.to_s.downcase }
                    if to_be_inserted_before
                      move_to_left_of(to_be_inserted_before)
                    elsif p.nil?
                      if sibs.empty?
                        # move_to_root adds the project in first (ie. left) position
                        move_to_root
                      else
                        move_to_right_of(sibs.last) unless self == sibs.last
                      end
                    else
                      # move_to_child_of adds the project in last (ie.right) position
                      move_to_child_of(p)
                    end
                    Issue.update_versions_from_hierarchy_change(self)
                    true
                  else
                    # Can not move to the given target
                    false
                  end
                end
                # Returns an array of the trackers used by the project and its active sub projects
                def rolled_up_trackers
                  @rolled_up_trackers ||=
                    Tracker.find(:all, :joins => :projects,
                                       :select => "DISTINCT #{Tracker.table_name}.*",
                                       :conditions => ["#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ? AND #{Project.table_name}.status = #{STATUS_ACTIVE}", lft, rgt],
                                       :order => "#{Tracker.table_name}.position")
                end
                # Closes open and locked project versions that are completed
                def close_completed_versions
                  Version.transaction do
                    versions.find(:all, :conditions => {:status => %w(open locked)}).each do |version|
                      if version.completed?
                        version.update_attribute(:status, 'closed')
                      end
                    end
                  end
                end
                # Returns a scope of the Versions on subprojects
                def rolled_up_versions
                  @rolled_up_versions ||=
                    Version.scoped(:include => :project,
                                   :conditions => ["#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ? AND #{Project.table_name}.status = #{STATUS_ACTIVE}", lft, rgt])
                end
                # Returns a scope of the Versions used by the project
                def shared_versions
                  @shared_versions ||= begin
                    r = root? ? self : root
                    Version.scoped(:include => :project,
                                   :conditions => "#{Project.table_name}.id = #{id}" +
                                                  " OR (#{Project.table_name}.status = #{Project::STATUS_ACTIVE} AND (" +
                                                        " #{Version.table_name}.sharing = 'system'" +
                                                        " OR (#{Project.table_name}.lft >= #{r.lft} AND #{Project.table_name}.rgt <= #{r.rgt} AND #{Version.table_name}.sharing = 'tree')" +
                                                        " OR (#{Project.table_name}.lft < #{lft} AND #{Project.table_name}.rgt > #{rgt} AND #{Version.table_name}.sharing IN ('hierarchy', 'descendants'))" +
                                                        " OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt} AND #{Version.table_name}.sharing = 'hierarchy')" +
                                                        "))")
                  end
                end
                # Returns a hash of project users grouped by role
                def users_by_role
                  members.find(:all, :include => [:user, :roles]).inject({}) do |h, m|
                    m.roles.each do |r|
                      h[r] ||= []
                      h[r] << m.user
                    end
                    h
                  end
                end
                # Deletes all project's members
                def delete_all_members
                  me, mr = Member.table_name, MemberRole.table_name
                  connection.delete("DELETE FROM #{mr} WHERE #{mr}.member_id IN (SELECT #{me}.id FROM #{me} WHERE #{me}.project_id = #{id})")
                  Member.delete_all(['project_id = ?', id])
                end
                # Users issues can be assigned to
                def assignable_users
                  members.select {|m| m.roles.detect {|role| role.assignable?}}.collect {|m| m.user}.sort
                end
                # Returns the mail adresses of users that should be always notified on project events
                def recipients
                  notified_users.collect {|user| user.mail}
                end
                # Returns the users that should be notified on project events
                def notified_users
                  # TODO: User part should be extracted to User#notify_about?
                  members.select {|m| m.mail_notification? || m.user.mail_notification == 'all'}.collect {|m| m.user}
                end
                # Returns an array of all custom fields enabled for project issues
                # (explictly associated custom fields and custom fields enabled for all projects)
                def all_issue_custom_fields
                  @all_issue_custom_fields ||= (IssueCustomField.for_all + issue_custom_fields).uniq.sort
                end
                # Returns an array of all custom fields enabled for project time entries
                # (explictly associated custom fields and custom fields enabled for all projects)
                def all_time_entry_custom_fields
                  @all_time_entry_custom_fields ||= (TimeEntryCustomField.for_all + time_entry_custom_fields).uniq.sort
                end
                def project
                  self
                end
                def <=>(project)
                  name.downcase <=> project.name.downcase
                end
                def to_s
                  name
                end
                # Returns a short description of the projects (first lines)
                def short_description(length = 255)
                  description.gsub(/^(.{#{length}}[^\n\r]*).*$/m, '\1...').strip if description
                end
                def css_classes
                  s = 'project'
                  s << ' root' if root?
                  s << ' child' if child?
                  s << (leaf? ? ' leaf' : ' parent')
                  s
                end
                # The earliest start date of a project, based on it's issues and versions
                def start_date
                  [
                   issues.minimum('start_date'),
                   shared_versions.collect(&:effective_date),
                   shared_versions.collect(&:start_date)
                  ].flatten.compact.min
                end
                # The latest due date of an issue or version
                def due_date
                  [
                   issues.maximum('due_date'),
                   shared_versions.collect(&:effective_date),
                   shared_versions.collect {|v| v.fixed_issues.maximum('due_date')}
                  ].flatten.compact.max
                end
                def overdue?
                  active? && !due_date.nil? && (due_date < Date.today)
                end
                # Returns the percent completed for this project, based on the
                # progress on it's versions.
                def completed_percent(options={:include_subprojects => false})
                  if options.delete(:include_subprojects)
                    total = self_and_descendants.collect(&:completed_percent).sum
                    total / self_and_descendants.count
                  else
                    if versions.count > 0
                      total = versions.collect(&:completed_pourcent).sum
                      total / versions.count
                    else
 
                    end
                  end
                end
                # Return true if this project is allowed to do the specified action.
                # action can be:
                # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
                # * a permission Symbol (eg. :edit_project)
                def allows_to?(action)
                  if action.is_a? Hash
                    allowed_actions.include? "#{action[:controller]}/#{action[:action]}"
                  else
                    allowed_permissions.include? action
                  end
                end
                def module_enabled?(module_name)
                  module_name = module_name.to_s
                  enabled_modules.detect {|m| m.name == module_name}
                end
                def enabled_module_names=(module_names)
                  if module_names && module_names.is_a?(Array)
                    module_names = module_names.collect(&:to_s).reject(&:blank?)
                    self.enabled_modules = module_names.collect {|name| enabled_modules.detect {|mod| mod.name == name} || EnabledModule.new(:name => name)}
                  else
                    enabled_modules.clear
                  end
                end
                # Returns an array of the enabled modules names
                def enabled_module_names
                  enabled_modules.collect(&:name)
                end
                safe_attributes 'name',
                  'description',
                  'homepage',
                  'is_public',
                  'identifier',
                  'custom_field_values',
                  'custom_fields',
                  'tracker_ids',
                  'issue_custom_field_ids'
                safe_attributes 'enabled_module_names',
                  :if => lambda {|project, user| project.new_record? || user.allowed_to?(:select_project_modules, project) }
                # Returns an array of projects that are in this project's hierarchy
                #
                # Example: parents, children, siblings
                def hierarchy
                  parents = project.self_and_ancestors || []
                  descendants = project.descendants || []
                  project_hierarchy = parents | descendants # Set union
                end
                # Returns an auto-generated project identifier based on the last identifier used
                def self.next_identifier
                  p = Project.find(:first, :order => 'created_on DESC')
                  p.nil? ? nil : p.identifier.to_s.succ
                end
                # Copies and saves the Project instance based on the +project+.
                # Duplicates the source project's:
                # * Wiki
                # * Versions
                # * Categories
                # * Issues
                # * Members
                # * Queries
                #
                # Accepts an +options+ argument to specify what to copy
                #
                # Examples:
                #   project.copy(1)                                    # => copies everything
                #   project.copy(1, :only => 'members')                # => copies members only
                #   project.copy(1, :only => ['members', 'versions'])  # => copies members and versions
                def copy(project, options={})
                  project = project.is_a?(Project) ? project : Project.find(project)
                  to_be_copied = %w(wiki versions issue_categories issues members queries boards)
                  to_be_copied = to_be_copied & options[:only].to_a unless options[:only].nil?
                  Project.transaction do
                    if save
                      reload
                      to_be_copied.each do |name|
                        send "copy_#{name}", project
                      end
                      Redmine::Hook.call_hook(:model_project_copy_before_save, :source_project => project, :destination_project => self)
                      save
                    end
                  end
                end
                # Copies +project+ and returns the new instance.  This will not save
                # the copy
                def self.copy_from(project)
                  begin
                    project = project.is_a?(Project) ? project : Project.find(project)
                    if project
                      # clear unique attributes
                      attributes = project.attributes.dup.except('id', 'name', 'identifier', 'status', 'parent_id', 'lft', 'rgt')
                      copy = Project.new(attributes)
                      copy.enabled_modules = project.enabled_modules
                      copy.trackers = project.trackers
                      copy.custom_values = project.custom_values.collect {|v| v.clone}
                      copy.issue_custom_fields = project.issue_custom_fields
                      return copy
                    else
                      return nil
                    end
                  rescue ActiveRecord::RecordNotFound
                    return nil
                  end
                end
                # Yields the given block for each project with its level in the tree
                def self.project_tree(projects, &block)
                  ancestors = []
                  projects.sort_by(&:lft).each do |project|
                    while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                      ancestors.pop
                    end
                    yield project, ancestors.size
                    ancestors << project
                  end
                end
                private
                # Copies wiki from +project+
                def copy_wiki(project)
                  # Check that the source project has a wiki first
                  unless project.wiki.nil?
                    self.wiki ||= Wiki.new
                    wiki.attributes = project.wiki.attributes.dup.except("id", "project_id")
                    wiki_pages_map = {}
                    project.wiki.pages.each do |page|
                      # Skip pages without content
                      next if page.content.nil?
                      new_wiki_content = WikiContent.new(page.content.attributes.dup.except("id", "page_id", "updated_on"))
                      new_wiki_page = WikiPage.new(page.attributes.dup.except("id", "wiki_id", "created_on", "parent_id"))
                      new_wiki_page.content = new_wiki_content
                      wiki.pages << new_wiki_page
                      wiki_pages_map[page.id] = new_wiki_page
                    end
                    wiki.save
                    # Reproduce page hierarchy
                    project.wiki.pages.each do |page|
                      if page.parent_id && wiki_pages_map[page.id]
                        wiki_pages_map[page.id].parent = wiki_pages_map[page.parent_id]
                        wiki_pages_map[page.id].save
                      end
                    end
                  end
                end
                # Copies versions from +project+
                def copy_versions(project)
                  project.versions.each do |version|
                    new_version = Version.new
                    new_version.attributes = version.attributes.dup.except("id", "project_id", "created_on", "updated_on")
                    self.versions << new_version
                  end
                end
                # Copies issue categories from +project+
                def copy_issue_categories(project)
                  project.issue_categories.each do |issue_category|
                    new_issue_category = IssueCategory.new
                    new_issue_category.attributes = issue_category.attributes.dup.except("id", "project_id")
                    self.issue_categories << new_issue_category
                  end
                end
                # Copies issues from +project+
                # Note: issues assigned to a closed version won't be copied due to validation rules
                def copy_issues(project)
                  # Stores the source issue id as a key and the copied issues as the
                  # value.  Used to map the two togeather for issue relations.
                  issues_map = {}
                  # Get issues sorted by root_id, lft so that parent issues
                  # get copied before their children
                  project.issues.find(:all, :order => 'root_id, lft').each do |issue|
                    new_issue = Issue.new
                    new_issue.copy_from(issue)
                    new_issue.project = self
                    # Reassign fixed_versions by name, since names are unique per
                    # project and the versions for self are not yet saved
                    if issue.fixed_version
                      new_issue.fixed_version = self.versions.select {|v| v.name == issue.fixed_version.name}.first
                    end
                    # Reassign the category by name, since names are unique per
                    # project and the categories for self are not yet saved
                    if issue.category
                      new_issue.category = self.issue_categories.select {|c| c.name == issue.category.name}.first
                    end
                    # Parent issue
                    if issue.parent_id
                      if copied_parent = issues_map[issue.parent_id]
                        new_issue.parent_issue_id = copied_parent.id
                      end
                    end
                    self.issues << new_issue
                    if new_issue.new_record?
                      logger.info "Project#copy_issues: issue ##{issue.id} could not be copied: #{new_issue.errors.full_messages}" if logger && logger.info
                    else
                      issues_map[issue.id] = new_issue unless new_issue.new_record?
                    end
                  end
                  # Relations after in case issues related each other
                  project.issues.each do |issue|
                    new_issue = issues_map[issue.id]
                    unless new_issue
                      # Issue was not copied
                      next
                    end
                    # Relations
                    issue.relations_from.each do |source_relation|
                      new_issue_relation = IssueRelation.new
                      new_issue_relation.attributes = source_relation.attributes.dup.except("id", "issue_from_id", "issue_to_id")
                      new_issue_relation.issue_to = issues_map[source_relation.issue_to_id]
                      if new_issue_relation.issue_to.nil? && Setting.cross_project_issue_relations?
                        new_issue_relation.issue_to = source_relation.issue_to
                      end
                      new_issue.relations_from << new_issue_relation
                    end
                    issue.relations_to.each do |source_relation|
                      new_issue_relation = IssueRelation.new
                      new_issue_relation.attributes = source_relation.attributes.dup.except("id", "issue_from_id", "issue_to_id")
                      new_issue_relation.issue_from = issues_map[source_relation.issue_from_id]
                      if new_issue_relation.issue_from.nil? && Setting.cross_project_issue_relations?
                        new_issue_relation.issue_from = source_relation.issue_from
                      end
                      new_issue.relations_to << new_issue_relation
                    end
                  end
                end
                # Copies members from +project+
                def copy_members(project)
                  # Copy users first, then groups to handle members with inherited and given roles
                  members_to_copy = []
                  members_to_copy += project.memberships.select {|m| m.principal.is_a?(User)}
                  members_to_copy += project.memberships.select {|m| !m.principal.is_a?(User)}
                  members_to_copy.each do |member|
                    new_member = Member.new
                    new_member.attributes = member.attributes.dup.except("id", "project_id", "created_on")
                    # only copy non inherited roles
                    # inherited roles will be added when copying the group membership
                    role_ids = member.member_roles.reject(&:inherited?).collect(&:role_id)
                    next if role_ids.empty?
                    new_member.role_ids = role_ids
                    new_member.project = self
                    self.members << new_member
                  end
                end
                # Copies queries from +project+
                def copy_queries(project)
                  project.queries.each do |query|
                    new_query = Query.new
                    new_query.attributes = query.attributes.dup.except("id", "project_id", "sort_criteria")
                    new_query.sort_criteria = query.sort_criteria if query.sort_criteria
                    new_query.project = self
                    self.queries << new_query
                  end
                end
                # Copies boards from +project+
                def copy_boards(project)
                  project.boards.each do |board|
                    new_board = Board.new
                    new_board.attributes = board.attributes.dup.except("id", "project_id", "topics_count", "messages_count", "last_message_id")
                    new_board.project = self
                    self.boards << new_board
                  end
                end
                def allowed_permissions
                  @allowed_permissions ||= begin
                    module_names = enabled_modules.all(:select => :name).collect {|m| m.name}
                    Redmine::AccessControl.modules_permissions(module_names).collect {|p| p.name}
                  end
                end
                def allowed_actions
                  @actions_allowed ||= allowed_permissions.inject([]) { |actions, permission| actions += Redmine::AccessControl.allowed_actions(permission) }.flatten
                end
                # Returns all the active Systemwide and project specific activities
                def active_activities
                  overridden_activity_ids = self.time_entry_activities.collect(&:parent_id)
                  if overridden_activity_ids.empty?
                    return TimeEntryActivity.shared.active
                  else
                    return system_activities_and_project_overrides
                  end
                end
                # Returns all the Systemwide and project specific activities
                # (inactive and active)
                def all_activities
                  overridden_activity_ids = self.time_entry_activities.collect(&:parent_id)
                  if overridden_activity_ids.empty?
                    return TimeEntryActivity.shared
                  else
                    return system_activities_and_project_overrides(true)
                  end
                end
                # Returns the systemwide active activities merged with the project specific overrides
                def system_activities_and_project_overrides(include_inactive=false)
                  if include_inactive
                    return TimeEntryActivity.shared.
                      find(:all,
                           :conditions => ["id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)]) +
                      self.time_entry_activities
                  else
                    return TimeEntryActivity.shared.active.
                      find(:all,
                           :conditions => ["id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)]) +
                      self.time_entry_activities.active
                  end
                end
                # Archives subprojects recursively
                def archive!
                  children.each do |subproject|
                    subproject.send :archive!
                  end
                  update_attribute :status, STATUS_ARCHIVED
                end
              end

app/models/role.rb +9 -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 Role < ActiveRecord::Base
                # Built-in roles
                BUILTIN_NON_MEMBER = 1
                BUILTIN_ANONYMOUS  = 2
+               ISSUES_VISIBILITY_OPTIONS = [
+                 ['default', :label_issues_visibility_all],
+                 ['own', :label_issues_visibility_own]
+               ]
                named_scope :givable, { :conditions => "builtin = 0", :order => 'position' }
                named_scope :builtin, lambda { |*args|
                  compare = 'not' if args.first == true
                  { :conditions => "#{compare} builtin = 0" }
                }
                before_destroy :check_deletable
                has_many :workflows, :dependent => :delete_all do
                  def copy(source_role)
                    Workflow.copy(nil, source_role, nil, proxy_owner)
                  end
                end
                has_many :member_roles, :dependent => :destroy
                has_many :members, :through => :member_roles
                acts_as_list
                serialize :permissions, Array
                attr_protected :builtin
                validates_presence_of :name
                validates_uniqueness_of :name
                validates_length_of :name, :maximum => 30
+               validates_inclusion_of :issues_visibility,
+                 :in => ISSUES_VISIBILITY_OPTIONS.collect(&:first),
+                 :if => lambda {|role| role.respond_to?(:issues_visibility)}
                def permissions
                  read_attribute(:permissions) || []
                end
                def permissions=(perms)
                  perms = perms.collect {|p| p.to_sym unless p.blank? }.compact.uniq if perms
                  write_attribute(:permissions, perms)
                end
                def add_permission!(*perms)
                  self.permissions = [] unless permissions.is_a?(Array)
                  permissions_will_change!
                  perms.each do |p|
                    p = p.to_sym
                    permissions << p unless permissions.include?(p)
                  end
                  save!
                end
                def remove_permission!(*perms)
                  return unless permissions.is_a?(Array)
                  permissions_will_change!
                  perms.each { |p| permissions.delete(p.to_sym) }
                  save!
                end
                # Returns true if the role has the given permission
                def has_permission?(perm)
                  !permissions.nil? && permissions.include?(perm.to_sym)
                end
                def <=>(role)
                  role ? position <=> role.position : -1
                end
                def to_s
                  name
                end
                def name
                  case builtin
                  when 1; l(:label_role_non_member, :default => read_attribute(:name))
                  when 2; l(:label_role_anonymous,  :default => read_attribute(:name))
                  else; read_attribute(:name)
                  end
                end
                # Return true if the role is a builtin role
                def builtin?
                  self.builtin != 0
                end
                # Return true if the role is a project member role
                def member?
                  !self.builtin?
                end
                # Return true if role is allowed to do the specified action
                # action can be:
                # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
                # * a permission Symbol (eg. :edit_project)
                def allowed_to?(action)
                  if action.is_a? Hash
                    allowed_actions.include? "#{action[:controller]}/#{action[:action]}"
                  else
                    allowed_permissions.include? action
                  end
                end
                # Return all the permissions that can be given to the role
                def setable_permissions
                  setable_permissions = Redmine::AccessControl.permissions - Redmine::AccessControl.public_permissions
                  setable_permissions -= Redmine::AccessControl.members_only_permissions if self.builtin == BUILTIN_NON_MEMBER
                  setable_permissions -= Redmine::AccessControl.loggedin_only_permissions if self.builtin == BUILTIN_ANONYMOUS
                  setable_permissions
                end
                # Find all the roles that can be given to a project member
                def self.find_all_givable
                  find(:all, :conditions => {:builtin => 0}, :order => 'position')
                end
                # Return the builtin 'non member' role.  If the role doesn't exist,
                # it will be created on the fly.
                def self.non_member
                  non_member_role = find(:first, :conditions => {:builtin => BUILTIN_NON_MEMBER})
                  if non_member_role.nil?
                    non_member_role = create(:name => 'Non member', :position => 0) do |role|
                      role.builtin = BUILTIN_NON_MEMBER
                    end
                    raise 'Unable to create the non-member role.' if non_member_role.new_record?
                  end
                  non_member_role
                end
                # Return the builtin 'anonymous' role.  If the role doesn't exist,
                # it will be created on the fly.
                def self.anonymous
                  anonymous_role = find(:first, :conditions => {:builtin => BUILTIN_ANONYMOUS})
                  if anonymous_role.nil?
                    anonymous_role = create(:name => 'Anonymous', :position => 0) do |role|
                      role.builtin = BUILTIN_ANONYMOUS
                    end
                    raise 'Unable to create the anonymous role.' if anonymous_role.new_record?
                  end
                  anonymous_role
                end
              private
                def allowed_permissions
                  @allowed_permissions ||= permissions + Redmine::AccessControl.public_permissions.collect {|p| p.name}
                end
                def allowed_actions
                  @actions_allowed ||= allowed_permissions.inject([]) { |actions, permission| actions += Redmine::AccessControl.allowed_actions(permission) }.flatten
                end
                def check_deletable
                  raise "Can't delete role" if members.any?
                  raise "Can't delete builtin role" if builtin?
                end
              end

app/models/user.rb +15 -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.
              require "digest/sha1"
              class User < Principal
                include Redmine::SafeAttributes
                # Account statuses
                STATUS_ANONYMOUS  = 0
                STATUS_ACTIVE     = 1
                STATUS_REGISTERED = 2
                STATUS_LOCKED     = 3
                USER_FORMATS = {
                  :firstname_lastname => '#{firstname} #{lastname}',
                  :firstname => '#{firstname}',
                  :lastname_firstname => '#{lastname} #{firstname}',
                  :lastname_coma_firstname => '#{lastname}, #{firstname}',
                  :username => '#{login}'
                }
                MAIL_NOTIFICATION_OPTIONS = [
                  ['all', :label_user_mail_option_all],
                  ['selected', :label_user_mail_option_selected],
                  ['only_my_events', :label_user_mail_option_only_my_events],
                  ['only_assigned', :label_user_mail_option_only_assigned],
                  ['only_owner', :label_user_mail_option_only_owner],
                  ['none', :label_user_mail_option_none]
                ]
                has_and_belongs_to_many :groups, :after_add => Proc.new {|user, group| group.user_added(user)},
                                                 :after_remove => Proc.new {|user, group| group.user_removed(user)}
                has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
                has_many :changesets, :dependent => :nullify
                has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
                has_one :rss_token, :class_name => 'Token', :conditions => "action='feeds'"
                has_one :api_token, :class_name => 'Token', :conditions => "action='api'"
                belongs_to :auth_source
                # Active non-anonymous users scope
                named_scope :active, :conditions => "#{User.table_name}.status = #{STATUS_ACTIVE}"
                acts_as_customizable
                attr_accessor :password, :password_confirmation
                attr_accessor :last_before_login_on
                # Prevents unauthorized assignments
                attr_protected :login, :admin, :password, :password_confirmation, :hashed_password
                validates_presence_of :login, :firstname, :lastname, :mail, :if => Proc.new { |user| !user.is_a?(AnonymousUser) }
                validates_uniqueness_of :login, :if => Proc.new { |user| !user.login.blank? }, :case_sensitive => false
                validates_uniqueness_of :mail, :if => Proc.new { |user| !user.mail.blank? }, :case_sensitive => false
                # Login must contain lettres, numbers, underscores only
                validates_format_of :login, :with => /^[a-z0-9_\-@\.]*$/i
                validates_length_of :login, :maximum => 30
                validates_length_of :firstname, :lastname, :maximum => 30
                validates_format_of :mail, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :allow_nil => true
                validates_length_of :mail, :maximum => 60, :allow_nil => true
                validates_confirmation_of :password, :allow_nil => true
                validates_inclusion_of :mail_notification, :in => MAIL_NOTIFICATION_OPTIONS.collect(&:first), :allow_blank => true
                before_destroy :remove_references_before_destroy
                named_scope :in_group, lambda {|group|
                  group_id = group.is_a?(Group) ? group.id : group.to_i
                  { :conditions => ["#{User.table_name}.id IN (SELECT gu.user_id FROM #{table_name_prefix}groups_users#{table_name_suffix} gu WHERE gu.group_id = ?)", group_id] }
                }
                named_scope :not_in_group, lambda {|group|
                  group_id = group.is_a?(Group) ? group.id : group.to_i
                  { :conditions => ["#{User.table_name}.id NOT IN (SELECT gu.user_id FROM #{table_name_prefix}groups_users#{table_name_suffix} gu WHERE gu.group_id = ?)", group_id] }
                }
                def before_create
                  self.mail_notification = Setting.default_notification_option if self.mail_notification.blank?
                  true
                end
                def before_save
                  # update hashed_password if password was set
                  if self.password && self.auth_source_id.blank?
                    salt_password(password)
                  end
                end
                def reload(*args)
                  @name = nil
                  @projects_by_role = nil
                  super
                end
                def mail=(arg)
                  write_attribute(:mail, arg.to_s.strip)
                end
                def identity_url=(url)
                  if url.blank?
                    write_attribute(:identity_url, '')
                  else
                    begin
                      write_attribute(:identity_url, OpenIdAuthentication.normalize_identifier(url))
                    rescue OpenIdAuthentication::InvalidOpenId
                      # Invlaid url, don't save
                    end
                  end
                  self.read_attribute(:identity_url)
                end
                # Returns the user that matches provided login and password, or nil
                def self.try_to_login(login, password)
                  # Make sure no one can sign in with an empty password
                  return nil if password.to_s.empty?
                  user = find_by_login(login)
                  if user
                    # user is already in local database
                    return nil if !user.active?
                    if user.auth_source
                      # user has an external authentication method
                      return nil unless user.auth_source.authenticate(login, password)
                    else
                      # authentication with local password
                      return nil unless user.check_password?(password)
                    end
                  else
                    # user is not yet registered, try to authenticate with available sources
                    attrs = AuthSource.authenticate(login, password)
                    if attrs
                      user = new(attrs)
                      user.login = login
                      user.language = Setting.default_language
                      if user.save
                        user.reload
                        logger.info("User '#{user.login}' created from external auth source: #{user.auth_source.type} - #{user.auth_source.name}") if logger && user.auth_source
                      end
                    end
                  end
                  user.update_attribute(:last_login_on, Time.now) if user && !user.new_record?
                  user
                rescue => text
                  raise text
                end
                # Returns the user who matches the given autologin +key+ or nil
                def self.try_to_autologin(key)
                  tokens = Token.find_all_by_action_and_value('autologin', key)
                  # Make sure there's only 1 token that matches the key
                  if tokens.size == 1
                    token = tokens.first
                    if (token.created_on > Setting.autologin.to_i.day.ago) && token.user && token.user.active?
                      token.user.update_attribute(:last_login_on, Time.now)
                      token.user
                    end
                  end
                end
                # Return user's full name for display
                def name(formatter = nil)
                  if formatter
                    eval('"' + (USER_FORMATS[formatter] || USER_FORMATS[:firstname_lastname]) + '"')
                  else
                    @name ||= eval('"' + (USER_FORMATS[Setting.user_format] || USER_FORMATS[:firstname_lastname]) + '"')
                  end
                end
                def active?
                  self.status == STATUS_ACTIVE
                end
                def registered?
                  self.status == STATUS_REGISTERED
                end
                def locked?
                  self.status == STATUS_LOCKED
                end
                def activate
                  self.status = STATUS_ACTIVE
                end
                def register
                  self.status = STATUS_REGISTERED
                end
                def lock
                  self.status = STATUS_LOCKED
                end
                def activate!
                  update_attribute(:status, STATUS_ACTIVE)
                end
                def register!
                  update_attribute(:status, STATUS_REGISTERED)
                end
                def lock!
                  update_attribute(:status, STATUS_LOCKED)
                end
                # Returns true if +clear_password+ is the correct user's password, otherwise false
                def check_password?(clear_password)
                  if auth_source_id.present?
                    auth_source.authenticate(self.login, clear_password)
                  else
                    User.hash_password("#{salt}#{User.hash_password clear_password}") == hashed_password
                  end
                end
                # Generates a random salt and computes hashed_password for +clear_password+
                # The hashed password is stored in the following form: SHA1(salt + SHA1(password))
                def salt_password(clear_password)
                  self.salt = User.generate_salt
                  self.hashed_password = User.hash_password("#{salt}#{User.hash_password clear_password}")
                end
                # Does the backend storage allow this user to change their password?
                def change_password_allowed?
                  return true if auth_source_id.blank?
                  return auth_source.allow_password_changes?
                end
                # Generate and set a random password.  Useful for automated user creation
                # Based on Token#generate_token_value
                #
                def random_password
                  chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
                  password = ''
 .times { |i| password << chars[rand(chars.size-1)] }
                  self.password = password
                  self.password_confirmation = password
                  self
                end
                def pref
                  self.preference ||= UserPreference.new(:user => self)
                end
                def time_zone
                  @time_zone ||= (self.pref.time_zone.blank? ? nil : ActiveSupport::TimeZone[self.pref.time_zone])
                end
                def wants_comments_in_reverse_order?
                  self.pref[:comments_sorting] == 'desc'
                end
                # Return user's RSS key (a 40 chars long string), used to access feeds
                def rss_key
                  token = self.rss_token || Token.create(:user => self, :action => 'feeds')
                  token.value
                end
                # Return user's API key (a 40 chars long string), used to access the API
                def api_key
                  token = self.api_token || self.create_api_token(:action => 'api')
                  token.value
                end
                # Return an array of project ids for which the user has explicitly turned mail notifications on
                def notified_projects_ids
                  @notified_projects_ids ||= memberships.select {|m| m.mail_notification?}.collect(&:project_id)
                end
                def notified_project_ids=(ids)
                  Member.update_all("mail_notification = #{connection.quoted_false}", ['user_id = ?', id])
                  Member.update_all("mail_notification = #{connection.quoted_true}", ['user_id = ? AND project_id IN (?)', id, ids]) if ids && !ids.empty?
                  @notified_projects_ids = nil
                  notified_projects_ids
                end
                def valid_notification_options
                  self.class.valid_notification_options(self)
                end
                # Only users that belong to more than 1 project can select projects for which they are notified
                def self.valid_notification_options(user=nil)
                  # Note that @user.membership.size would fail since AR ignores
                  # :include association option when doing a count
                  if user.nil? || user.memberships.length < 1
                    MAIL_NOTIFICATION_OPTIONS.reject {|option| option.first == 'selected'}
                  else
                    MAIL_NOTIFICATION_OPTIONS
                  end
                end
                # Find a user account by matching the exact login and then a case-insensitive
                # version.  Exact matches will be given priority.
                def self.find_by_login(login)
                  # force string comparison to be case sensitive on MySQL
                  type_cast = (ActiveRecord::Base.connection.adapter_name == 'MySQL') ? 'BINARY' : ''
                  # First look for an exact match
                  user = first(:conditions => ["#{type_cast} login = ?", login])
                  # Fail over to case-insensitive if none was found
                  user ||= first(:conditions => ["#{type_cast} LOWER(login) = ?", login.to_s.downcase])
                end
                def self.find_by_rss_key(key)
                  token = Token.find_by_value(key)
                  token && token.user.active? ? token.user : nil
                end
                def self.find_by_api_key(key)
                  token = Token.find_by_action_and_value('api', key)
                  token && token.user.active? ? token.user : nil
                end
                # Makes find_by_mail case-insensitive
                def self.find_by_mail(mail)
                  find(:first, :conditions => ["LOWER(mail) = ?", mail.to_s.downcase])
                end
                def to_s
                  name
                end
                # Returns the current day according to user's time zone
                def today
                  if time_zone.nil?
                    Date.today
                  else
                    Time.now.in_time_zone(time_zone).to_date
                  end
                end
                def logged?
                  true
                end
                def anonymous?
                  !logged?
                end
                # Return user's roles for project
                def roles_for_project(project)
                  roles = []
                  # No role on archived projects
                  return roles unless project && project.active?
                  if logged?
                    # Find project membership
                    membership = memberships.detect {|m| m.project_id == project.id}
                    if membership
                      roles = membership.roles
                    else
                      @role_non_member ||= Role.non_member
                      roles << @role_non_member
                    end
                  else
                    @role_anonymous ||= Role.anonymous
                    roles << @role_anonymous
                  end
                  roles
                end
                # Return true if the user is a member of project
                def member_of?(project)
                  !roles_for_project(project).detect {|role| role.member?}.nil?
                end
                # Returns a hash of user's projects grouped by roles
                def projects_by_role
                  return @projects_by_role if @projects_by_role
                  @projects_by_role = Hash.new {|h,k| h[k]=[]}
                  memberships.each do |membership|
                    membership.roles.each do |role|
                      @projects_by_role[role] << membership.project if membership.project
                    end
                  end
                  @projects_by_role.each do |role, projects|
                    projects.uniq!
                  end
                  @projects_by_role
                end
                # Return true if the user is allowed to do the specified action on a specific context
                # Action can be:
                # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
                # * a permission Symbol (eg. :edit_project)
                # Context can be:
                # * a project : returns true if user is allowed to do the specified action on this project
-               # * a group of projects : returns true if user is allowed on every project
+               # * an array of projects : returns true if user is allowed on every project
                # * nil with options[:global] set : check if user has at least one role allowed for this action,
                #   or falls back to Non Member / Anonymous permissions depending if the user is logged
-               def allowed_to?(action, context, options={})
+               def allowed_to?(action, context, options={}, &block)
                  if context && context.is_a?(Project)
                    # No action allowed on archived projects
                    return false unless context.active?
                    # No action allowed on disabled modules
                    return false unless context.allows_to?(action)
                    # Admin users are authorized for anything else
                    return true if admin?
                    roles = roles_for_project(context)
                    return false unless roles
-                   roles.detect {|role| (context.is_public? || role.member?) && role.allowed_to?(action)}
+                   roles.detect {|role|
+                     (context.is_public? || role.member?) &&
+                     role.allowed_to?(action) &&
+                     (block_given? ? yield(role, self) : true)
+                   }
                  elsif context && context.is_a?(Array)
                    # Authorize if user is authorized on every element of the array
                    context.map do |project|
-                     allowed_to?(action,project,options)
+                     allowed_to?(action, project, options, &block)
                    end.inject do |memo,allowed|
                      memo && allowed
                    end
                  elsif options[:global]
                    # Admin users are always authorized
                    return true if admin?
                    # authorize if user has at least one role that has this permission
                    roles = memberships.collect {|m| m.roles}.flatten.uniq
-                   roles.detect {|r| r.allowed_to?(action)} || (self.logged? ? Role.non_member.allowed_to?(action) : Role.anonymous.allowed_to?(action))
+                   roles << (self.logged? ? Role.non_member : Role.anonymous)
+                   roles.detect {|role|
+                     role.allowed_to?(action) &&
+                     (block_given? ? yield(role, self) : true)
+                   }
                  else
                    false
                  end
                end
                # Is the user allowed to do the specified action on any project?
                # See allowed_to? for the actions and valid options.
-               def allowed_to_globally?(action, options)
-                 allowed_to?(action, nil, options.reverse_merge(:global => true))
+               def allowed_to_globally?(action, options, &block)
+                 allowed_to?(action, nil, options.reverse_merge(:global => true), &block)
                end
                safe_attributes 'login',
                  'firstname',
                  'lastname',
                  'mail',
                  'mail_notification',
                  'language',
                  'custom_field_values',
                  'custom_fields',
                  'identity_url'
                safe_attributes 'status',
                  'auth_source_id',
                  :if => lambda {|user, current_user| current_user.admin?}
                safe_attributes 'group_ids',
                  :if => lambda {|user, current_user| current_user.admin? && !user.new_record?}
                # Utility method to help check if a user should be notified about an
                # event.
                #
                # TODO: only supports Issue events currently
                def notify_about?(object)
                  case mail_notification
                  when 'all'
                    true
                  when 'selected'
                    # user receives notifications for created/assigned issues on unselected projects
                    if object.is_a?(Issue) && (object.author == self || object.assigned_to == self)
                      true
                    else
                      false
                    end
                  when 'none'
                    false
                  when 'only_my_events'
                    if object.is_a?(Issue) && (object.author == self || object.assigned_to == self)
                      true
                    else
                      false
                    end
                  when 'only_assigned'
                    if object.is_a?(Issue) && object.assigned_to == self
                      true
                    else
                      false
                    end
                  when 'only_owner'
                    if object.is_a?(Issue) && object.author == self
                      true
                    else
                      false
                    end
                  else
                    false
                  end
                end
                def self.current=(user)
                  @current_user = user
                end
                def self.current
                  @current_user ||= User.anonymous
                end
                # Returns the anonymous user.  If the anonymous user does not exist, it is created.  There can be only
                # one anonymous user per database.
                def self.anonymous
                  anonymous_user = AnonymousUser.find(:first)
                  if anonymous_user.nil?
                    anonymous_user = AnonymousUser.create(:lastname => 'Anonymous', :firstname => '', :mail => '', :login => '', :status => 0)
                    raise 'Unable to create the anonymous user.' if anonymous_user.new_record?
                  end
                  anonymous_user
                end
                # Salts all existing unsalted passwords
                # It changes password storage scheme from SHA1(password) to SHA1(salt + SHA1(password))
                # This method is used in the SaltPasswords migration and is to be kept as is
                def self.salt_unsalted_passwords!
                  transaction do
                    User.find_each(:conditions => "salt IS NULL OR salt = ''") do |user|
                      next if user.hashed_password.blank?
                      salt = User.generate_salt
                      hashed_password = User.hash_password("#{salt}#{user.hashed_password}")
                      User.update_all("salt = '#{salt}', hashed_password = '#{hashed_password}'", ["id = ?", user.id] )
                    end
                  end
                end
                protected
                def validate
                  # Password length validation based on setting
                  if !password.nil? && password.size < Setting.password_min_length.to_i
                    errors.add(:password, :too_short, :count => Setting.password_min_length.to_i)
                  end
                end
                private
                # Removes references that are not handled by associations
                # Things that are not deleted are reassociated with the anonymous user
                def remove_references_before_destroy
                  return if self.id.nil?
                  substitute = User.anonymous
                  Attachment.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                  Comment.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                  Issue.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                  Issue.update_all 'assigned_to_id = NULL', ['assigned_to_id = ?', id]
                  Journal.update_all ['user_id = ?', substitute.id], ['user_id = ?', id]
                  JournalDetail.update_all ['old_value = ?', substitute.id.to_s], ["property = 'attr' AND prop_key = 'assigned_to_id' AND old_value = ?", id.to_s]
                  JournalDetail.update_all ['value = ?', substitute.id.to_s], ["property = 'attr' AND prop_key = 'assigned_to_id' AND value = ?", id.to_s]
                  Message.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                  News.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                  # Remove private queries and keep public ones
                  Query.delete_all ['user_id = ? AND is_public = ?', id, false]
                  Query.update_all ['user_id = ?', substitute.id], ['user_id = ?', id]
                  TimeEntry.update_all ['user_id = ?', substitute.id], ['user_id = ?', id]
                  Token.delete_all ['user_id = ?', id]
                  Watcher.delete_all ['user_id = ?', id]
                  WikiContent.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                  WikiContent::Version.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                end
                # Return password digest
                def self.hash_password(clear_password)
                  Digest::SHA1.hexdigest(clear_password || "")
                end
                # Returns a 128bits random salt as a hex string (32 chars long)
                def self.generate_salt
                  ActiveSupport::SecureRandom.hex(16)
                end
              end
              class AnonymousUser < User
                def validate_on_create
                  # There should be only one AnonymousUser in the database
                  errors.add_to_base 'An anonymous user already exists.' if AnonymousUser.find(:first)
                end
                def available_custom_fields
                  []
                end
                # Overrides a few properties
                def logged?; false end
                def admin; false end
                def name(*args); I18n.t(:label_user_anonymous) end
                def mail; nil end
                def time_zone; nil end
                def rss_key; nil end
                # Anonymous user can not be destroyed
                def destroy
                  false
                end
              end

app/views/roles/_form.rhtml +3 -2

              <%= error_messages_for 'role' %>
-             <% unless @role.builtin? %>
              <div class="box">
+             <% unless @role.builtin? %>
              <p><%= f.text_field :name, :required => true %></p>
              <p><%= f.check_box :assignable %></p>
+             <% end %>
+             <p><%= f.select :issues_visibility, Role::ISSUES_VISIBILITY_OPTIONS.collect {|v| [l(v.last), v.first]} %></p>
              <% if @role.new_record? && @roles.any? %>
              <p><label><%= l(:label_copy_workflow_from) %></label>
              <%= select_tag(:copy_workflow_from, content_tag("option") + options_from_collection_for_select(@roles, :id, :name)) %></p>
              <% end %>
              </div>
-             <% end %>
              <h3><%= l(:label_permissions) %></h3>
              <div class="box" id="permissions">
              <% perms_by_module = @permissions.group_by {|p| p.project_module.to_s} %>
              <% perms_by_module.keys.sort.each do |mod| %>
                  <fieldset><legend><%= mod.blank? ? l(:label_project) : l_or_humanize(mod, :prefix => 'project_module_') %></legend>
                  <% perms_by_module[mod].each do |permission| %>
                      <label class="floating">
                      <%= check_box_tag 'role[permissions][]', permission.name, (@role.permissions.include? permission.name) %>
                      <%= l_or_humanize(permission.name, :prefix => 'permission_') %>
                      </label>
                  <% end %>
                  </fieldset>
              <% end %>
              <br /><%= check_all_links 'permissions' %>
              <%= hidden_field_tag 'role[permissions][]', '' %>
              </div>

config/locales/en.yml +3 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_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})"
                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_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})"
                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
                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: Attachment max. 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: Feed content limit
                setting_default_projects_public: New projects are public by default
                setting_autofetch_changesets: Autofetch commits
                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: Repositories encodings
                setting_commit_logs_encoding: Commit messages encoding
                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: Max number of diff lines displayed
                setting_file_max_size_displayed: Max 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
                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_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
                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_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_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_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_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_own: Issues created by or assigned to the user
                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
                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 and dashes 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_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."
                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

config/locales/fr.yml +3 0

              # French translations for Ruby on Rails
              # by Christian Lescuyer (christian@flyingcoders.com)
              # contributor: Sebastien Grosjean - ZenCocoon.com
              # contributor: Thibaut Cuvelier - Developpez.com
              fr:
                direction: ltr
                date:
                  formats:
                    default: "%d/%m/%Y"
                    short: "%e %b"
                    long: "%e %B %Y"
                    long_ordinal: "%e %B %Y"
                    only_day: "%e"
                  day_names: [dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi]
                  abbr_day_names: [dim, lun, mar, mer, jeu, ven, sam]
                  month_names: [~, janvier, février, mars, avril, mai, juin, juillet, août, septembre, octobre, novembre, décembre]
                  abbr_month_names: [~, jan., fév., mar., avr., mai, juin, juil., août, sept., oct., nov., déc.]
                  order: [ :day, :month, :year ]
                time:
                  formats:
                    default: "%d/%m/%Y %H:%M"
                    time: "%H:%M"
                    short: "%d %b %H:%M"
                    long: "%A %d %B %Y %H:%M:%S %Z"
                    long_ordinal: "%A %d %B %Y %H:%M:%S %Z"
                    only_second: "%S"
                  am: 'am'
                  pm: 'pm'
                datetime:
                  distance_in_words:
                    half_a_minute: "30 secondes"
                    less_than_x_seconds:
                      zero:  "moins d'une seconde"
                      one:   "moins d'une seconde"
                      other: "moins de %{count} secondes"
                    x_seconds:
                      one:   "1 seconde"
                      other: "%{count} secondes"
                    less_than_x_minutes:
                      zero:  "moins d'une minute"
                      one:   "moins d'une minute"
                      other: "moins de %{count} minutes"
                    x_minutes:
                      one:   "1 minute"
                      other: "%{count} minutes"
                    about_x_hours:
                      one:   "environ une heure"
                      other: "environ %{count} heures"
                    x_days:
                      one:   "un jour"
                      other: "%{count} jours"
                    about_x_months:
                      one:   "environ un mois"
                      other: "environ %{count} mois"
                    x_months:
                      one:   "un mois"
                      other: "%{count} mois"
                    about_x_years:
                      one:   "environ un an"
                      other: "environ %{count} ans"
                    over_x_years:
                      one:   "plus d'un an"
                      other: "plus de %{count} ans"
                    almost_x_years:
                      one:   "presqu'un an"
                      other: "presque %{count} ans"
                  prompts:
                    year:   "Année"
                    month:  "Mois"
                    day:    "Jour"
                    hour:   "Heure"
                    minute: "Minute"
                    second: "Seconde"
                number:
                  format:
                    precision: 3
                    separator: ','
                    delimiter: ' '
                  currency:
                    format:
                      unit: '€'
                      precision: 2
                      format: '%n %u'
                  human:
                    format:
                      precision: 2
                    storage_units:
                      format: "%n %u"
                      units:
                        byte:
                          one: "octet"
                          other: "octet"
                        kb: "ko"
                        mb: "Mo"
                        gb: "Go"
                        tb: "To"
                support:
                  array:
                    sentence_connector: 'et'
                    skip_last_comma: true
                    word_connector: ", "
                    two_words_connector: " et "
                    last_word_connector: " et "
                activerecord:
                  errors:
                    template:
                      header:
                        one: "Impossible d'enregistrer %{model} : une erreur"
                        other: "Impossible d'enregistrer %{model} : %{count} erreurs."
                      body: "Veuillez vérifier les champs suivants :"
                    messages:
                      inclusion: "n'est pas inclus(e) dans la liste"
                      exclusion: "n'est pas disponible"
                      invalid: "n'est pas valide"
                      confirmation: "ne concorde pas avec la confirmation"
                      accepted: "doit être accepté(e)"
                      empty: "doit être renseigné(e)"
                      blank: "doit être renseigné(e)"
                      too_long: "est trop long (pas plus de %{count} caractères)"
                      too_short: "est trop court (au moins %{count} caractères)"
                      wrong_length: "ne fait pas la bonne longueur (doit comporter %{count} caractères)"
                      taken: "est déjà utilisé"
                      not_a_number: "n'est pas un nombre"
                      not_a_date: "n'est pas une date valide"
                      greater_than: "doit être supérieur à %{count}"
                      greater_than_or_equal_to: "doit être supérieur ou égal à %{count}"
                      equal_to: "doit être égal à %{count}"
                      less_than: "doit être inférieur à %{count}"
                      less_than_or_equal_to: "doit être inférieur ou égal à %{count}"
                      odd: "doit être impair"
                      even: "doit être pair"
                      greater_than_start_date: "doit être postérieure à la date de début"
                      not_same_project: "n'appartient pas au même projet"
                      circular_dependency: "Cette relation créerait une dépendance circulaire"
                      cant_link_an_issue_with_a_descendant: "Une demande ne peut pas être liée à l'une de ses sous-tâches"
                actionview_instancetag_blank_option: Choisir
                general_text_No: 'Non'
                general_text_Yes: 'Oui'
                general_text_no: 'non'
                general_text_yes: 'oui'
                general_lang_name: 'Français'
                general_csv_separator: ';'
                general_csv_decimal_separator: ','
                general_csv_encoding: ISO-8859-1
                general_pdf_encoding: UTF-8
                general_first_day_of_week: '1'
                notice_account_updated: Le compte a été mis à jour avec succès.
                notice_account_invalid_creditentials: Identifiant ou mot de passe invalide.
                notice_account_password_updated: Mot de passe mis à jour avec succès.
                notice_account_wrong_password: Mot de passe incorrect
                notice_account_register_done: Un message contenant les instructions pour activer votre compte vous a été envoyé.
                notice_account_unknown_email: Aucun compte ne correspond à cette adresse.
                notice_can_t_change_password: Ce compte utilise une authentification externe. Impossible de changer le mot de passe.
                notice_account_lost_email_sent: Un message contenant les instructions pour choisir un nouveau mot de passe vous a été envoyé.
                notice_account_activated: Votre compte a été activé. Vous pouvez à présent vous connecter.
                notice_successful_create: Création effectuée avec succès.
                notice_successful_update: Mise à jour effectuée avec succès.
                notice_successful_delete: Suppression effectuée avec succès.
                notice_successful_connection: Connexion réussie.
                notice_file_not_found: "La page à laquelle vous souhaitez accéder n'existe pas ou a été supprimée."
                notice_locking_conflict: Les données ont été mises à jour par un autre utilisateur. Mise à jour impossible.
                notice_not_authorized: "Vous n'êtes pas autorisé à accéder à cette page."
                notice_not_authorized_archived_project: Le projet auquel vous tentez d'accéder a été archivé.
                notice_email_sent: "Un email a été envoyé à %{value}"
                notice_email_error: "Erreur lors de l'envoi de l'email (%{value})"
                notice_feeds_access_key_reseted: "Votre clé d'accès aux flux RSS a été réinitialisée."
                notice_failed_to_save_issues: "%{count} demande(s) sur les %{total} sélectionnées n'ont pas pu être mise(s) à jour : %{ids}."
                notice_no_issue_selected: "Aucune demande sélectionnée ! Cochez les demandes que vous voulez mettre à jour."
                notice_account_pending: "Votre compte a été créé et attend l'approbation de l'administrateur."
                notice_default_data_loaded: Paramétrage par défaut chargé avec succès.
                notice_unable_delete_version: Impossible de supprimer cette version.
                notice_issue_done_ratios_updated: L'avancement des demandes a été mis à jour.
                notice_api_access_key_reseted: Votre clé d'accès API a été réinitialisée.
                notice_gantt_chart_truncated: "Le diagramme a été tronqué car il excède le nombre maximal d'éléments pouvant être affichés (%{max})"
                error_can_t_load_default_data: "Une erreur s'est produite lors du chargement du paramétrage : %{value}"
                error_scm_not_found: "L'entrée et/ou la révision demandée n'existe pas dans le dépôt."
                error_scm_command_failed: "Une erreur s'est produite lors de l'accès au dépôt : %{value}"
                error_scm_annotate: "L'entrée n'existe pas ou ne peut pas être annotée."
                error_issue_not_found_in_project: "La demande n'existe pas ou n'appartient pas à ce projet"
                error_can_not_reopen_issue_on_closed_version: 'Une demande assignée à une version fermée ne peut pas être réouverte'
                error_can_not_archive_project: "Ce projet ne peut pas être archivé"
                error_workflow_copy_source: 'Veuillez sélectionner un tracker et/ou un rôle source'
                error_workflow_copy_target: 'Veuillez sélectionner les trackers et rôles cibles'
                error_issue_done_ratios_not_updated: L'avancement des demandes n'a pas pu être mis à jour.
                warning_attachments_not_saved: "%{count} fichier(s) n'ont pas pu être sauvegardés."
                mail_subject_lost_password: "Votre mot de passe %{value}"
                mail_body_lost_password: 'Pour changer votre mot de passe, cliquez sur le lien suivant :'
                mail_subject_register: "Activation de votre compte %{value}"
                mail_body_register: 'Pour activer votre compte, cliquez sur le lien suivant :'
                mail_body_account_information_external: "Vous pouvez utiliser votre compte %{value} pour vous connecter."
                mail_body_account_information: Paramètres de connexion de votre compte
                mail_subject_account_activation_request: "Demande d'activation d'un compte %{value}"
                mail_body_account_activation_request: "Un nouvel utilisateur (%{value}) s'est inscrit. Son compte nécessite votre approbation :"
                mail_subject_reminder: "%{count} demande(s) arrivent à échéance (%{days})"
                mail_body_reminder: "%{count} demande(s) qui vous sont assignées arrivent à échéance dans les %{days} prochains jours :"
                mail_subject_wiki_content_added: "Page wiki '%{id}' ajoutée"
                mail_body_wiki_content_added: "La page wiki '%{id}' a été ajoutée par %{author}."
                mail_subject_wiki_content_updated: "Page wiki '%{id}' mise à jour"
                mail_body_wiki_content_updated: "La page wiki '%{id}' a été mise à jour par %{author}."
                gui_validation_error: 1 erreur
                gui_validation_error_plural: "%{count} erreurs"
                field_name: Nom
                field_description: Description
                field_summary: Résumé
                field_is_required: Obligatoire
                field_firstname: Prénom
                field_lastname: Nom
                field_mail: "Email "
                field_filename: Fichier
                field_filesize: Taille
                field_downloads: Téléchargements
                field_author: Auteur
                field_created_on: "Créé "
                field_updated_on: "Mis-à-jour "
                field_field_format: Format
                field_is_for_all: Pour tous les projets
                field_possible_values: Valeurs possibles
                field_regexp: Expression régulière
                field_min_length: Longueur minimum
                field_max_length: Longueur maximum
                field_value: Valeur
                field_category: Catégorie
                field_title: Titre
                field_project: Projet
                field_issue: Demande
                field_status: Statut
                field_notes: Notes
                field_is_closed: Demande fermée
                field_is_default: Valeur par défaut
                field_tracker: Tracker
                field_subject: Sujet
                field_due_date: Echéance
                field_assigned_to: Assigné à
                field_priority: Priorité
                field_fixed_version: Version cible
                field_user: Utilisateur
                field_role: Rôle
                field_homepage: "Site web "
                field_is_public: Public
                field_parent: Sous-projet de
                field_is_in_roadmap: Demandes affichées dans la roadmap
                field_login: "Identifiant "
                field_mail_notification: Notifications par mail
                field_admin: Administrateur
                field_last_login_on: "Dernière connexion "
                field_language: Langue
                field_effective_date: Date
                field_password: Mot de passe
                field_new_password: Nouveau mot de passe
                field_password_confirmation: Confirmation
                field_version: Version
                field_type: Type
                field_host: Hôte
                field_port: Port
                field_account: Compte
                field_base_dn: Base DN
                field_attr_login: Attribut Identifiant
                field_attr_firstname: Attribut Prénom
                field_attr_lastname: Attribut Nom
                field_attr_mail: Attribut Email
                field_onthefly: Création des utilisateurs à la volée
                field_start_date: Début
                field_done_ratio: % réalisé
                field_auth_source: Mode d'authentification
                field_hide_mail: Cacher mon adresse mail
                field_comments: Commentaire
                field_url: URL
                field_start_page: Page de démarrage
                field_subproject: Sous-projet
                field_hours: Heures
                field_activity: Activité
                field_spent_on: Date
                field_identifier: Identifiant
                field_is_filter: Utilisé comme filtre
                field_issue_to: Demande liée
                field_delay: Retard
                field_assignable: Demandes assignables à ce rôle
                field_redirect_existing_links: Rediriger les liens existants
                field_estimated_hours: Temps estimé
                field_column_names: Colonnes
                field_time_zone: Fuseau horaire
                field_searchable: Utilisé pour les recherches
                field_default_value: Valeur par défaut
                field_comments_sorting: Afficher les commentaires
                field_parent_title: Page parent
                field_editable: Modifiable
                field_watcher: Observateur
                field_identity_url: URL OpenID
                field_content: Contenu
                field_group_by: Grouper par
                field_sharing: Partage
                field_active: Actif
                field_parent_issue: Tâche parente
                field_visible: Visible
                field_warn_on_leaving_unsaved: "M'avertir lorsque je quitte une page contenant du texte non sauvegardé"
+               field_issues_visibility: Visibilité des demandes
                setting_app_title: Titre de l'application
                setting_app_subtitle: Sous-titre de l'application
                setting_welcome_text: Texte d'accueil
                setting_default_language: Langue par défaut
                setting_login_required: Authentification obligatoire
                setting_self_registration: Inscription des nouveaux utilisateurs
                setting_attachment_max_size: Taille max des fichiers
                setting_issues_export_limit: Limite export demandes
                setting_mail_from: Adresse d'émission
                setting_bcc_recipients: Destinataires en copie cachée (cci)
                setting_plain_text_mail: Mail texte brut (non HTML)
                setting_host_name: Nom d'hôte et chemin
                setting_text_formatting: Formatage du texte
                setting_wiki_compression: Compression historique wiki
                setting_feeds_limit: Limite du contenu des flux RSS
                setting_default_projects_public: Définir les nouveaux projets comme publics par défaut
                setting_autofetch_changesets: Récupération auto. des commits
                setting_sys_api_enabled: Activer les WS pour la gestion des dépôts
                setting_commit_ref_keywords: Mots-clés de référencement
                setting_commit_fix_keywords: Mots-clés de résolution
                setting_autologin: Autologin
                setting_date_format: Format de date
                setting_time_format: Format d'heure
                setting_cross_project_issue_relations: Autoriser les relations entre demandes de différents projets
                setting_issue_list_default_columns: Colonnes affichées par défaut sur la liste des demandes
                setting_repositories_encodings: Encodages des dépôts
                setting_commit_logs_encoding: Encodage des messages de commit
                setting_emails_footer: Pied-de-page des emails
                setting_protocol: Protocole
                setting_per_page_options: Options d'objets affichés par page
                setting_user_format: Format d'affichage des utilisateurs
                setting_activity_days_default: Nombre de jours affichés sur l'activité des projets
                setting_display_subprojects_issues: Afficher par défaut les demandes des sous-projets sur les projets principaux
                setting_enabled_scm: SCM activés
                setting_mail_handler_body_delimiters: "Tronquer les emails après l'une de ces lignes"
                setting_mail_handler_api_enabled: "Activer le WS pour la réception d'emails"
                setting_mail_handler_api_key: Clé de protection de l'API
                setting_sequential_project_identifiers: Générer des identifiants de projet séquentiels
                setting_gravatar_enabled: Afficher les Gravatar des utilisateurs
                setting_diff_max_lines_displayed: Nombre maximum de lignes de diff affichées
                setting_file_max_size_displayed: Taille maximum des fichiers texte affichés en ligne
                setting_repository_log_display_limit: "Nombre maximum de révisions affichées sur l'historique d'un fichier"
                setting_openid: "Autoriser l'authentification et l'enregistrement OpenID"
                setting_password_min_length: Longueur minimum des mots de passe
                setting_new_project_user_role_id: Rôle donné à un utilisateur non-administrateur qui crée un projet
                setting_default_projects_modules: Modules activés par défaut pour les nouveaux projets
                setting_issue_done_ratio: Calcul de l'avancement des demandes
                setting_issue_done_ratio_issue_status: Utiliser le statut
                setting_issue_done_ratio_issue_field: 'Utiliser le champ % effectué'
                setting_rest_api_enabled: Activer l'API REST
                setting_gravatar_default: Image Gravatar par défaut
                setting_start_of_week: Jour de début des calendriers
                setting_cache_formatted_text: Mettre en cache le texte formaté
                setting_commit_logtime_enabled: Permettre la saisie de temps
                setting_commit_logtime_activity_id: Activité pour le temps saisi
                setting_gantt_items_limit: Nombre maximum d'éléments affichés sur le gantt
                permission_add_project: Créer un projet
                permission_add_subprojects: Créer des sous-projets
                permission_edit_project: Modifier le projet
                permission_select_project_modules: Choisir les modules
                permission_manage_members: Gérer les membres
                permission_manage_versions: Gérer les versions
                permission_manage_categories: Gérer les catégories de demandes
                permission_view_issues: Voir les demandes
                permission_add_issues: Créer des demandes
                permission_edit_issues: Modifier les demandes
                permission_manage_issue_relations: Gérer les relations
                permission_add_issue_notes: Ajouter des notes
                permission_edit_issue_notes: Modifier les notes
                permission_edit_own_issue_notes: Modifier ses propres notes
                permission_move_issues: Déplacer les demandes
                permission_delete_issues: Supprimer les demandes
                permission_manage_public_queries: Gérer les requêtes publiques
                permission_save_queries: Sauvegarder les requêtes
                permission_view_gantt: Voir le gantt
                permission_view_calendar: Voir le calendrier
                permission_view_issue_watchers: Voir la liste des observateurs
                permission_add_issue_watchers: Ajouter des observateurs
                permission_delete_issue_watchers: Supprimer des observateurs
                permission_log_time: Saisir le temps passé
                permission_view_time_entries: Voir le temps passé
                permission_edit_time_entries: Modifier les temps passés
                permission_edit_own_time_entries: Modifier son propre temps passé
                permission_manage_news: Gérer les annonces
                permission_comment_news: Commenter les annonces
                permission_manage_documents: Gérer les documents
                permission_view_documents: Voir les documents
                permission_manage_files: Gérer les fichiers
                permission_view_files: Voir les fichiers
                permission_manage_wiki: Gérer le wiki
                permission_rename_wiki_pages: Renommer les pages
                permission_delete_wiki_pages: Supprimer les pages
                permission_view_wiki_pages: Voir le wiki
                permission_view_wiki_edits: "Voir l'historique des modifications"
                permission_edit_wiki_pages: Modifier les pages
                permission_delete_wiki_pages_attachments: Supprimer les fichiers joints
                permission_protect_wiki_pages: Protéger les pages
                permission_manage_repository: Gérer le dépôt de sources
                permission_browse_repository: Parcourir les sources
                permission_view_changesets: Voir les révisions
                permission_commit_access: Droit de commit
                permission_manage_boards: Gérer les forums
                permission_view_messages: Voir les messages
                permission_add_messages: Poster un message
                permission_edit_messages: Modifier les messages
                permission_edit_own_messages: Modifier ses propres messages
                permission_delete_messages: Supprimer les messages
                permission_delete_own_messages: Supprimer ses propres messages
                permission_export_wiki_pages: Exporter les pages
                permission_manage_project_activities: Gérer les activités
                permission_manage_subtasks: Gérer les sous-tâches
                project_module_issue_tracking: Suivi des demandes
                project_module_time_tracking: Suivi du temps passé
                project_module_news: Publication d'annonces
                project_module_documents: Publication de documents
                project_module_files: Publication de fichiers
                project_module_wiki: Wiki
                project_module_repository: Dépôt de sources
                project_module_boards: Forums de discussion
                label_user: Utilisateur
                label_user_plural: Utilisateurs
                label_user_new: Nouvel utilisateur
                label_user_anonymous: Anonyme
                label_project: Projet
                label_project_new: Nouveau projet
                label_project_plural: Projets
                label_x_projects:
                  zero:  aucun projet
                  one:   un projet
                  other: "%{count} projets"
                label_project_all: Tous les projets
                label_project_latest: Derniers projets
                label_issue: Demande
                label_issue_new: Nouvelle demande
                label_issue_plural: Demandes
                label_issue_view_all: Voir toutes les demandes
                label_issue_added: Demande ajoutée
                label_issue_updated: Demande mise à jour
                label_issue_note_added: Note ajoutée
                label_issue_status_updated: Statut changé
                label_issue_priority_updated: Priorité changée
                label_issues_by: "Demandes par %{value}"
                label_document: Document
                label_document_new: Nouveau document
                label_document_plural: Documents
                label_document_added: Document ajouté
                label_role: Rôle
                label_role_plural: Rôles
                label_role_new: Nouveau rôle
                label_role_and_permissions: Rôles et permissions
                label_role_anonymous: Anonyme
                label_role_non_member: Non membre
                label_member: Membre
                label_member_new: Nouveau membre
                label_member_plural: Membres
                label_tracker: Tracker
                label_tracker_plural: Trackers
                label_tracker_new: Nouveau tracker
                label_workflow: Workflow
                label_issue_status: Statut de demandes
                label_issue_status_plural: Statuts de demandes
                label_issue_status_new: Nouveau statut
                label_issue_category: Catégorie de demandes
                label_issue_category_plural: Catégories de demandes
                label_issue_category_new: Nouvelle catégorie
                label_custom_field: Champ personnalisé
                label_custom_field_plural: Champs personnalisés
                label_custom_field_new: Nouveau champ personnalisé
                label_enumerations: Listes de valeurs
                label_enumeration_new: Nouvelle valeur
                label_information: Information
                label_information_plural: Informations
                label_please_login: Identification
                label_register: S'enregistrer
                label_login_with_open_id_option: S'authentifier avec OpenID
                label_password_lost: Mot de passe perdu
                label_home: Accueil
                label_my_page: Ma page
                label_my_account: Mon compte
                label_my_projects: Mes projets
                label_my_page_block: Blocs disponibles
                label_administration: Administration
                label_login: Connexion
                label_logout: Déconnexion
                label_help: Aide
                label_reported_issues: "Demandes soumises "
                label_assigned_to_me_issues: Demandes qui me sont assignées
                label_last_login: "Dernière connexion "
                label_registered_on: "Inscrit le "
                label_activity: Activité
                label_overall_activity: Activité globale
                label_user_activity: "Activité de %{value}"
                label_new: Nouveau
                label_logged_as: Connecté en tant que
                label_environment: Environnement
                label_authentication: Authentification
                label_auth_source: Mode d'authentification
                label_auth_source_new: Nouveau mode d'authentification
                label_auth_source_plural: Modes d'authentification
                label_subproject_plural: Sous-projets
                label_subproject_new: Nouveau sous-projet
                label_and_its_subprojects: "%{value} et ses sous-projets"
                label_min_max_length: Longueurs mini - maxi
                label_list: Liste
                label_date: Date
                label_integer: Entier
                label_float: Nombre décimal
                label_boolean: Booléen
                label_string: Texte
                label_text: Texte long
                label_attribute: Attribut
                label_attribute_plural: Attributs
                label_download: "%{count} téléchargement"
                label_download_plural: "%{count} téléchargements"
                label_no_data: Aucune donnée à afficher
                label_change_status: Changer le statut
                label_history: Historique
                label_attachment: Fichier
                label_attachment_new: Nouveau fichier
                label_attachment_delete: Supprimer le fichier
                label_attachment_plural: Fichiers
                label_file_added: Fichier ajouté
                label_report: Rapport
                label_report_plural: Rapports
                label_news: Annonce
                label_news_new: Nouvelle annonce
                label_news_plural: Annonces
                label_news_latest: Dernières annonces
                label_news_view_all: Voir toutes les annonces
                label_news_added: Annonce ajoutée
                label_news_comment_added: Commentaire ajouté à une annonce
                label_settings: Configuration
                label_overview: Aperçu
                label_version: Version
                label_version_new: Nouvelle version
                label_version_plural: Versions
                label_confirmation: Confirmation
                label_export_to: 'Formats disponibles :'
                label_read: Lire...
                label_public_projects: Projets publics
                label_open_issues: ouvert
                label_open_issues_plural: ouverts
                label_closed_issues: fermé
                label_closed_issues_plural: fermés
                label_x_open_issues_abbr_on_total:
                  zero:  0 ouvert sur %{total}
                  one:   1 ouvert sur %{total}
                  other: "%{count} ouverts sur %{total}"
                label_x_open_issues_abbr:
                  zero:  0 ouvert
                  one:   1 ouvert
                  other: "%{count} ouverts"
                label_x_closed_issues_abbr:
                  zero:  0 fermé
                  one:   1 fermé
                  other: "%{count} fermés"
                label_total: Total
                label_permissions: Permissions
                label_current_status: Statut actuel
                label_new_statuses_allowed: Nouveaux statuts autorisés
                label_all: tous
                label_none: aucun
                label_nobody: personne
                label_next: Suivant
                label_previous: Précédent
                label_used_by: Utilisé par
                label_details: Détails
                label_add_note: Ajouter une note
                label_per_page: Par page
                label_calendar: Calendrier
                label_months_from: mois depuis
                label_gantt: Gantt
                label_internal: Interne
                label_last_changes: "%{count} derniers changements"
                label_change_view_all: Voir tous les changements
                label_personalize_page: Personnaliser cette page
                label_comment: Commentaire
                label_comment_plural: Commentaires
                label_x_comments:
                  zero: aucun commentaire
                  one: un commentaire
                  other: "%{count} commentaires"
                label_comment_add: Ajouter un commentaire
                label_comment_added: Commentaire ajouté
                label_comment_delete: Supprimer les commentaires
                label_query: Rapport personnalisé
                label_query_plural: Rapports personnalisés
                label_query_new: Nouveau rapport
                label_my_queries: Mes rapports personnalisés
                label_filter_add: "Ajouter le filtre "
                label_filter_plural: Filtres
                label_equals: égal
                label_not_equals: différent
                label_in_less_than: dans moins de
                label_in_more_than: dans plus de
                label_in: dans
                label_today: aujourd'hui
                label_all_time: toute la période
                label_yesterday: hier
                label_this_week: cette semaine
                label_last_week: la semaine dernière
                label_last_n_days: "les %{count} derniers jours"
                label_this_month: ce mois-ci
                label_last_month: le mois dernier
                label_this_year: cette année
                label_date_range: Période
                label_less_than_ago: il y a moins de
                label_more_than_ago: il y a plus de
                label_ago: il y a
                label_contains: contient
                label_not_contains: ne contient pas
                label_day_plural: jours
                label_repository: Dépôt
                label_repository_plural: Dépôts
                label_browse: Parcourir
                label_modification: "%{count} modification"
                label_modification_plural: "%{count} modifications"
                label_revision: "Révision "
                label_revision_plural: Révisions
                label_associated_revisions: Révisions associées
                label_added: ajouté
                label_modified: modifié
                label_copied: copié
                label_renamed: renommé
                label_deleted: supprimé
                label_latest_revision: Dernière révision
                label_latest_revision_plural: Dernières révisions
                label_view_revisions: Voir les révisions
                label_max_size: Taille maximale
                label_sort_highest: Remonter en premier
                label_sort_higher: Remonter
                label_sort_lower: Descendre
                label_sort_lowest: Descendre en dernier
                label_roadmap: Roadmap
                label_roadmap_due_in: "Échéance dans %{value}"
                label_roadmap_overdue: "En retard de %{value}"
                label_roadmap_no_issues: Aucune demande pour cette version
                label_search: "Recherche "
                label_result_plural: Résultats
                label_all_words: Tous les mots
                label_wiki: Wiki
                label_wiki_edit: Révision wiki
                label_wiki_edit_plural: Révisions wiki
                label_wiki_page: Page wiki
                label_wiki_page_plural: Pages wiki
                label_index_by_title: Index par titre
                label_index_by_date: Index par date
                label_current_version: Version actuelle
                label_preview: Prévisualisation
                label_feed_plural: Flux RSS
                label_changes_details: Détails de tous les changements
                label_issue_tracking: Suivi des demandes
                label_spent_time: Temps passé
                label_f_hour: "%{value} heure"
                label_f_hour_plural: "%{value} heures"
                label_time_tracking: Suivi du temps
                label_change_plural: Changements
                label_statistics: Statistiques
                label_commits_per_month: Commits par mois
                label_commits_per_author: Commits par auteur
                label_view_diff: Voir les différences
                label_diff_inline: en ligne
                label_diff_side_by_side: côte à côte
                label_options: Options
                label_copy_workflow_from: Copier le workflow de
                label_permissions_report: Synthèse des permissions
                label_watched_issues: Demandes surveillées
                label_related_issues: Demandes liées
                label_applied_status: Statut appliqué
                label_loading: Chargement...
                label_relation_new: Nouvelle relation
                label_relation_delete: Supprimer la relation
                label_relates_to: lié à
                label_duplicates: duplique
                label_duplicated_by: dupliqué par
                label_blocks: bloque
                label_blocked_by: bloqué par
                label_precedes: précède
                label_follows: suit
                label_end_to_start: fin à début
                label_end_to_end: fin à fin
                label_start_to_start: début à début
                label_start_to_end: début à fin
                label_stay_logged_in: Rester connecté
                label_disabled: désactivé
                label_show_completed_versions: Voir les versions passées
                label_me: moi
                label_board: Forum
                label_board_new: Nouveau forum
                label_board_plural: Forums
                label_topic_plural: Discussions
                label_message_plural: Messages
                label_message_last: Dernier message
                label_message_new: Nouveau message
                label_message_posted: Message ajouté
                label_reply_plural: Réponses
                label_send_information: Envoyer les informations à l'utilisateur
                label_year: Année
                label_month: Mois
                label_week: Semaine
                label_date_from: Du
                label_date_to: Au
                label_language_based: Basé sur la langue de l'utilisateur
                label_sort_by: "Trier par %{value}"
                label_send_test_email: Envoyer un email de test
                label_feeds_access_key_created_on: "Clé d'accès RSS créée il y a %{value}"
                label_module_plural: Modules
                label_added_time_by: "Ajouté par %{author} il y a %{age}"
                label_updated_time_by: "Mis à jour par %{author} il y a %{age}"
                label_updated_time: "Mis à jour il y a %{value}"
                label_jump_to_a_project: Aller à un projet...
                label_file_plural: Fichiers
                label_changeset_plural: Révisions
                label_default_columns: Colonnes par défaut
                label_no_change_option: (Pas de changement)
                label_bulk_edit_selected_issues: Modifier les demandes sélectionnées
                label_theme: Thème
                label_default: Défaut
                label_search_titles_only: Uniquement dans les titres
                label_user_mail_option_all: "Pour tous les événements de tous mes projets"
                label_user_mail_option_selected: "Pour tous les événements des projets sélectionnés..."
                label_user_mail_no_self_notified: "Je ne veux pas être notifié des changements que j'effectue"
                label_registration_activation_by_email: activation du compte par email
                label_registration_manual_activation: activation manuelle du compte
                label_registration_automatic_activation: activation automatique du compte
                label_display_per_page: "Par page : %{value}"
                label_age: Âge
                label_change_properties: Changer les propriétés
                label_general: Général
                label_more: Plus
                label_scm: SCM
                label_plugins: Plugins
                label_ldap_authentication: Authentification LDAP
                label_downloads_abbr: D/L
                label_optional_description: Description facultative
                label_add_another_file: Ajouter un autre fichier
                label_preferences: Préférences
                label_chronological_order: Dans l'ordre chronologique
                label_reverse_chronological_order: Dans l'ordre chronologique inverse
                label_planning: Planning
                label_incoming_emails: Emails entrants
                label_generate_key: Générer une clé
                label_issue_watchers: Observateurs
                label_example: Exemple
                label_display: Affichage
                label_sort: Tri
                label_ascending: Croissant
                label_descending: Décroissant
                label_date_from_to: Du %{start} au %{end}
                label_wiki_content_added: Page wiki ajoutée
                label_wiki_content_updated: Page wiki mise à jour
                label_group_plural: Groupes
                label_group: Groupe
                label_group_new: Nouveau groupe
                label_time_entry_plural: Temps passé
                label_version_sharing_none: Non partagé
                label_version_sharing_descendants: Avec les sous-projets
                label_version_sharing_hierarchy: Avec toute la hiérarchie
                label_version_sharing_tree: Avec tout l'arbre
                label_version_sharing_system: Avec tous les projets
                label_copy_source: Source
                label_copy_target: Cible
                label_copy_same_as_target: Comme la cible
                label_update_issue_done_ratios: Mettre à jour l'avancement des demandes
                label_display_used_statuses_only: N'afficher que les statuts utilisés dans ce tracker
                label_api_access_key: Clé d'accès API
                label_api_access_key_created_on: Clé d'accès API créée il y a %{value}
                label_feeds_access_key: Clé d'accès RSS
                label_missing_api_access_key: Clé d'accès API manquante
                label_missing_feeds_access_key: Clé d'accès RSS manquante
                label_close_versions: Fermer les versions terminées
                label_revision_id: Revision %{value}
                label_profile: Profil
                label_subtask_plural: Sous-tâches
                label_project_copy_notifications: Envoyer les notifications durant la copie du projet
                label_principal_search: "Rechercher un utilisateur ou un groupe :"
                label_user_search: "Rechercher un utilisateur :"
                label_additional_workflow_transitions_for_author: Autorisations supplémentaires lorsque l'utilisateur a créé la demande
                label_additional_workflow_transitions_for_assignee: Autorisations supplémentaires lorsque la demande est assignée à l'utilisateur
+               label_issues_visibility_all: Toutes les demandes
+               label_issues_visibility_own: Demandes créées par ou assignées à l'utilisateur
                button_login: Connexion
                button_submit: Soumettre
                button_save: Sauvegarder
                button_check_all: Tout cocher
                button_uncheck_all: Tout décocher
                button_collapse_all: Plier tout
                button_expand_all: Déplier tout
                button_delete: Supprimer
                button_create: Créer
                button_create_and_continue: Créer et continuer
                button_test: Tester
                button_edit: Modifier
                button_add: Ajouter
                button_change: Changer
                button_apply: Appliquer
                button_clear: Effacer
                button_lock: Verrouiller
                button_unlock: Déverrouiller
                button_download: Télécharger
                button_list: Lister
                button_view: Voir
                button_move: Déplacer
                button_move_and_follow: Déplacer et suivre
                button_back: Retour
                button_cancel: Annuler
                button_activate: Activer
                button_sort: Trier
                button_log_time: Saisir temps
                button_rollback: Revenir à cette version
                button_watch: Surveiller
                button_unwatch: Ne plus surveiller
                button_reply: Répondre
                button_archive: Archiver
                button_unarchive: Désarchiver
                button_reset: Réinitialiser
                button_rename: Renommer
                button_change_password: Changer de mot de passe
                button_copy: Copier
                button_copy_and_follow: Copier et suivre
                button_annotate: Annoter
                button_update: Mettre à jour
                button_configure: Configurer
                button_quote: Citer
                button_duplicate: Dupliquer
                button_show: Afficher
                status_active: actif
                status_registered: enregistré
                status_locked: verrouillé
                version_status_open: ouvert
                version_status_locked: verrouillé
                version_status_closed: fermé
                text_select_mail_notifications: Actions pour lesquelles une notification par e-mail est envoyée
                text_regexp_info: ex. ^[A-Z0-9]+$
                text_min_max_length_info: 0 pour aucune restriction
                text_project_destroy_confirmation: Êtes-vous sûr de vouloir supprimer ce projet et toutes ses données ?
                text_subprojects_destroy_warning: "Ses sous-projets : %{value} seront également supprimés."
                text_workflow_edit: Sélectionner un tracker et un rôle pour éditer le workflow
                text_are_you_sure: Êtes-vous sûr ?
                text_tip_issue_begin_day: tâche commençant ce jour
                text_tip_issue_end_day: tâche finissant ce jour
                text_tip_issue_begin_end_day: tâche commençant et finissant ce jour
                text_project_identifier_info: 'Seuls les lettres minuscules (a-z), chiffres et tirets sont autorisés.<br />Un fois sauvegardé, l''identifiant ne pourra plus être modifié.'
                text_caracters_maximum: "%{count} caractères maximum."
                text_caracters_minimum: "%{count} caractères minimum."
                text_length_between: "Longueur comprise entre %{min} et %{max} caractères."
                text_tracker_no_workflow: Aucun worflow n'est défini pour ce tracker
                text_unallowed_characters: Caractères non autorisés
                text_comma_separated: Plusieurs valeurs possibles (séparées par des virgules).
                text_line_separated: Plusieurs valeurs possibles (une valeur par ligne).
                text_issues_ref_in_commit_messages: Référencement et résolution des demandes dans les commentaires de commits
                text_issue_added: "La demande %{id} a été soumise par %{author}."
                text_issue_updated: "La demande %{id} a été mise à jour par %{author}."
                text_wiki_destroy_confirmation: Etes-vous sûr de vouloir supprimer ce wiki et tout son contenu ?
                text_issue_category_destroy_question: "%{count} demandes sont affectées à cette catégorie. Que voulez-vous faire ?"
                text_issue_category_destroy_assignments: N'affecter les demandes à aucune autre catégorie
                text_issue_category_reassign_to: Réaffecter les demandes à cette catégorie
                text_user_mail_option: "Pour les projets non sélectionnés, vous recevrez seulement des notifications pour ce que vous surveillez ou à quoi vous participez (exemple: demandes dont vous êtes l'auteur ou la personne assignée)."
                text_no_configuration_data: "Les rôles, trackers, statuts et le workflow ne sont pas encore paramétrés.\nIl est vivement recommandé de charger le paramétrage par defaut. Vous pourrez le modifier une fois chargé."
                text_load_default_configuration: Charger le paramétrage par défaut
                text_status_changed_by_changeset: "Appliqué par commit %{value}."
                text_time_logged_by_changeset: "Appliqué par commit %{value}"
                text_issues_destroy_confirmation: 'Êtes-vous sûr de vouloir supprimer le(s) demandes(s) selectionnée(s) ?'
                text_select_project_modules: 'Sélectionner les modules à activer pour ce projet :'
                text_default_administrator_account_changed: Compte administrateur par défaut changé
                text_file_repository_writable: Répertoire de stockage des fichiers accessible en écriture
                text_plugin_assets_writable: Répertoire public des plugins accessible en écriture
                text_rmagick_available: Bibliothèque RMagick présente (optionnelle)
                text_destroy_time_entries_question: "%{hours} heures ont été enregistrées sur les demandes à supprimer. Que voulez-vous faire ?"
                text_destroy_time_entries: Supprimer les heures
                text_assign_time_entries_to_project: Reporter les heures sur le projet
                text_reassign_time_entries: 'Reporter les heures sur cette demande:'
                text_user_wrote: "%{value} a écrit :"
                text_enumeration_destroy_question: "Cette valeur est affectée à %{count} objets."
                text_enumeration_category_reassign_to: 'Réaffecter les objets à cette valeur:'
                text_email_delivery_not_configured: "L'envoi de mail n'est pas configuré, les notifications sont désactivées.\nConfigurez votre serveur SMTP dans config/configuration.yml et redémarrez l'application pour les activer."
                text_repository_usernames_mapping: "Vous pouvez sélectionner ou modifier l'utilisateur Redmine associé à chaque nom d'utilisateur figurant dans l'historique du dépôt.\nLes utilisateurs avec le même identifiant ou la même adresse mail seront automatiquement associés."
                text_diff_truncated: '... Ce différentiel a été tronqué car il excède la taille maximale pouvant être affichée.'
                text_custom_field_possible_values_info: 'Une ligne par valeur'
                text_wiki_page_destroy_question: "Cette page possède %{descendants} sous-page(s) et descendante(s). Que voulez-vous faire ?"
                text_wiki_page_nullify_children: "Conserver les sous-pages en tant que pages racines"
                text_wiki_page_destroy_children: "Supprimer les sous-pages et toutes leurs descedantes"
                text_wiki_page_reassign_children: "Réaffecter les sous-pages à cette page"
                text_own_membership_delete_confirmation: "Vous allez supprimer tout ou partie de vos permissions sur ce projet et ne serez peut-être plus autorisé à modifier ce projet.\nEtes-vous sûr de vouloir continuer ?"
                text_warn_on_leaving_unsaved: "Cette page contient du texte non sauvegardé qui sera perdu si vous quittez la page."
                default_role_manager: "Manager "
                default_role_developer: "Développeur "
                default_role_reporter: "Rapporteur "
                default_tracker_bug: Anomalie
                default_tracker_feature: Evolution
                default_tracker_support: Assistance
                default_issue_status_new: Nouveau
                default_issue_status_in_progress: En cours
                default_issue_status_resolved: Résolu
                default_issue_status_feedback: Commentaire
                default_issue_status_closed: Fermé
                default_issue_status_rejected: Rejeté
                default_doc_category_user: Documentation utilisateur
                default_doc_category_tech: Documentation technique
                default_priority_low: Bas
                default_priority_normal: Normal
                default_priority_high: Haut
                default_priority_urgent: Urgent
                default_priority_immediate: Immédiat
                default_activity_design: Conception
                default_activity_development: Développement
                enumeration_issue_priorities: Priorités des demandes
                enumeration_doc_categories: Catégories des documents
                enumeration_activities: Activités (suivi du temps)
                label_greater_or_equal: ">="
                label_less_or_equal: "<="
                label_view_all_revisions: Voir toutes les révisions
                label_tag: Tag
                label_branch: Branche
                error_no_tracker_in_project: "Aucun tracker n'est associé à ce projet. Vérifier la configuration du projet."
                error_no_default_issue_status: "Aucun statut de demande n'est défini par défaut. Vérifier votre configuration (Administration -> Statuts de demandes)."
                text_journal_changed: "%{label} changé de %{old} à %{new}"
                text_journal_changed_no_detail: "%{label} mis à jour"
                text_journal_set_to: "%{label} mis à %{value}"
                text_journal_deleted: "%{label} %{old} supprimé"
                text_journal_added: "%{label} %{value} ajouté"
                enumeration_system_activity: Activité système
                label_board_sticky: Sticky
                label_board_locked: Verrouillé
                error_unable_delete_issue_status: Impossible de supprimer le statut de demande
                error_can_not_delete_custom_field: Impossible de supprimer le champ personnalisé
                error_unable_to_connect: Connexion impossible (%{value})
                error_can_not_remove_role: Ce rôle est utilisé et ne peut pas être supprimé.
                error_can_not_delete_tracker: Ce tracker contient des demandes et ne peut pas être supprimé.
                field_principal: Principal
                notice_failed_to_save_members: "Erreur lors de la sauvegarde des membres: %{errors}."
                text_zoom_out: Zoom arrière
                text_zoom_in: Zoom avant
                notice_unable_delete_time_entry: Impossible de supprimer le temps passé.
                label_overall_spent_time: Temps passé global
                field_time_entries: Log time
                project_module_gantt: Gantt
                project_module_calendar: Calendrier
                button_edit_associated_wikipage: "Modifier la page wiki associée: %{page_title}"
                text_are_you_sure_with_children: Supprimer la demande et toutes ses sous-demandes ?
                field_text: Champ texte
                label_user_mail_option_only_owner: Seulement pour ce que j'ai créé
                setting_default_notification_option: Option de notification par défaut
                label_user_mail_option_only_my_events: Seulement pour ce que je surveille
                label_user_mail_option_only_assigned: Seulement pour ce qui m'est assigné
                label_user_mail_option_none: Aucune notification
                field_member_of_group: Groupe de l'assigné
                field_assigned_to_role: Rôle de l'assigné
                setting_emails_header: En-tête des emails
                label_bulk_edit_selected_time_entries: Bulk edit selected time entries
                text_time_entries_destroy_confirmation: Are you sure you want to delete the selected time entr(y/ies)?

test/fixtures/roles.yml +5 0

              ---
              roles_001:
                name: Manager
                id: 1
                builtin: 0
+               issues_visibility: default
                permissions: |
                  ---
                  - :add_project
                  - :edit_project
                  - :select_project_modules
                  - :manage_members
                  - :manage_versions
                  - :manage_categories
                  - :view_issues
                  - :add_issues
                  - :edit_issues
                  - :manage_issue_relations
                  - :manage_subtasks
                  - :add_issue_notes
                  - :move_issues
                  - :delete_issues
                  - :view_issue_watchers
                  - :add_issue_watchers
                  - :delete_issue_watchers
                  - :manage_public_queries
                  - :save_queries
                  - :view_gantt
                  - :view_calendar
                  - :log_time
                  - :view_time_entries
                  - :edit_time_entries
                  - :delete_time_entries
                  - :manage_news
                  - :comment_news
                  - :view_documents
                  - :manage_documents
                  - :view_wiki_pages
                  - :export_wiki_pages
                  - :view_wiki_edits
                  - :edit_wiki_pages
                  - :delete_wiki_pages_attachments
                  - :protect_wiki_pages
                  - :delete_wiki_pages
                  - :rename_wiki_pages
                  - :add_messages
                  - :edit_messages
                  - :delete_messages
                  - :manage_boards
                  - :view_files
                  - :manage_files
                  - :browse_repository
                  - :manage_repository
                  - :view_changesets
                  - :manage_project_activities
                position: 1
              roles_002:
                name: Developer
                id: 2
                builtin: 0
+               issues_visibility: default
                permissions: |
                  ---
                  - :edit_project
                  - :manage_members
                  - :manage_versions
                  - :manage_categories
                  - :view_issues
                  - :add_issues
                  - :edit_issues
                  - :manage_issue_relations
                  - :manage_subtasks
                  - :add_issue_notes
                  - :move_issues
                  - :delete_issues
                  - :view_issue_watchers
                  - :save_queries
                  - :view_gantt
                  - :view_calendar
                  - :log_time
                  - :view_time_entries
                  - :edit_own_time_entries
                  - :manage_news
                  - :comment_news
                  - :view_documents
                  - :manage_documents
                  - :view_wiki_pages
                  - :view_wiki_edits
                  - :edit_wiki_pages
                  - :protect_wiki_pages
                  - :delete_wiki_pages
                  - :add_messages
                  - :edit_own_messages
                  - :delete_own_messages
                  - :manage_boards
                  - :view_files
                  - :manage_files
                  - :browse_repository
                  - :view_changesets
                position: 2
              roles_003:
                name: Reporter
                id: 3
                builtin: 0
+               issues_visibility: default
                permissions: |
                  ---
                  - :edit_project
                  - :manage_members
                  - :manage_versions
                  - :manage_categories
                  - :view_issues
                  - :add_issues
                  - :edit_issues
                  - :manage_issue_relations
                  - :add_issue_notes
                  - :move_issues
                  - :view_issue_watchers
                  - :save_queries
                  - :view_gantt
                  - :view_calendar
                  - :log_time
                  - :view_time_entries
                  - :manage_news
                  - :comment_news
                  - :view_documents
                  - :manage_documents
                  - :view_wiki_pages
                  - :view_wiki_edits
                  - :edit_wiki_pages
                  - :delete_wiki_pages
                  - :add_messages
                  - :manage_boards
                  - :view_files
                  - :manage_files
                  - :browse_repository
                  - :view_changesets
                position: 3
              roles_004:
                name: Non member
                id: 4
                builtin: 1
+               issues_visibility: default
                permissions: |
                  ---
                  - :view_issues
                  - :add_issues
                  - :edit_issues
                  - :manage_issue_relations
                  - :add_issue_notes
                  - :move_issues
                  - :save_queries
                  - :view_gantt
                  - :view_calendar
                  - :log_time
                  - :view_time_entries
                  - :comment_news
                  - :view_documents
                  - :manage_documents
                  - :view_wiki_pages
                  - :view_wiki_edits
                  - :edit_wiki_pages
                  - :add_messages
                  - :view_files
                  - :manage_files
                  - :browse_repository
                  - :view_changesets
                position: 4
              roles_005:
                name: Anonymous
                id: 5
                builtin: 2
+               issues_visibility: default
                permissions: |
                  ---
                  - :view_issues
                  - :add_issue_notes
                  - :view_gantt
                  - :view_calendar
                  - :view_time_entries
                  - :view_documents
                  - :view_wiki_pages
                  - :view_wiki_edits
                  - :view_files
                  - :browse_repository
                  - :view_changesets
                position: 5

test/unit/issue_test.rb +45 -3

              # 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 IssueTest < ActiveSupport::TestCase
                fixtures :projects, :users, :members, :member_roles, :roles,
                         :trackers, :projects_trackers,
                         :enabled_modules,
                         :versions,
                         :issue_statuses, :issue_categories, :issue_relations, :workflows,
                         :enumerations,
                         :issues,
                         :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
                         :time_entries
                def test_create
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create', :description => 'IssueTest#test_create', :estimated_hours => '1:30')
                  assert issue.save
                  issue.reload
                  assert_equal 1.5, issue.estimated_hours
                end
                def test_create_minimal
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create')
                  assert issue.save
                  assert issue.description.nil?
                end
                def test_create_with_required_custom_field
                  field = IssueCustomField.find_by_name('Database')
                  field.update_attribute(:is_required, true)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field')
                  assert issue.available_custom_fields.include?(field)
                  # No value for the custom field
                  assert !issue.save
                  assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
                  # Blank value
                  issue.custom_field_values = { field.id => '' }
                  assert !issue.save
                  assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
                  # Invalid value
                  issue.custom_field_values = { field.id => 'SQLServer' }
                  assert !issue.save
                  assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
                  # Valid value
                  issue.custom_field_values = { field.id => 'PostgreSQL' }
                  assert issue.save
                  issue.reload
                  assert_equal 'PostgreSQL', issue.custom_value_for(field).value
                end
+               def assert_visibility_match(user, issues)
+                 assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort
+               end
                def test_visible_scope_for_anonymous
                  # Anonymous user should see issues of public projects only
                  issues = Issue.visible(User.anonymous).all
                  assert issues.any?
                  assert_nil issues.detect {|issue| !issue.project.is_public?}
+                 assert_visibility_match User.anonymous, issues
+               end
+               def test_visible_scope_for_anonymous_with_own_issues_visibility
+                 Role.anonymous.update_attribute :issues_visibility, 'own'
+                 Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => User.anonymous.id, :subject => 'Issue by anonymous')
+                 issues = Issue.visible(User.anonymous).all
+                 assert issues.any?
+                 assert_nil issues.detect {|issue| issue.author != User.anonymous}
+                 assert_visibility_match User.anonymous, issues
+               end
+               def test_visible_scope_for_anonymous_without_view_issues_permissions
                  # Anonymous user should not see issues without permission
                  Role.anonymous.remove_permission!(:view_issues)
                  issues = Issue.visible(User.anonymous).all
                  assert issues.empty?
+                 assert_visibility_match User.anonymous, issues
                end
-               def test_visible_scope_for_user
+               def test_visible_scope_for_non_member
                  user = User.find(9)
                  assert user.projects.empty?
                  # Non member user should see issues of public projects only
                  issues = Issue.visible(user).all
                  assert issues.any?
                  assert_nil issues.detect {|issue| !issue.project.is_public?}
+                 assert_visibility_match user, issues
+               end
+               def test_visible_scope_for_non_member_with_own_issues_visibility
+                 Role.non_member.update_attribute :issues_visibility, 'own'
+                 Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')
+                 user = User.find(9)
+                 issues = Issue.visible(user).all
+                 assert issues.any?
+                 assert_nil issues.detect {|issue| issue.author != user}
+                 assert_visibility_match user, issues
+               end
+               def test_visible_scope_for_non_member_without_view_issues_permissions
                  # Non member user should not see issues without permission
                  Role.non_member.remove_permission!(:view_issues)
-                 user.reload
+                 user = User.find(9)
+                 assert user.projects.empty?
                  issues = Issue.visible(user).all
                  assert issues.empty?
+                 assert_visibility_match user, issues
+               end
+               def test_visible_scope_for_member
+                 user = User.find(9)
                  # User should see issues of projects for which he has view_issues permissions only
+                 Role.non_member.remove_permission!(:view_issues)
                  Member.create!(:principal => user, :project_id => 2, :role_ids => [1])
-                 user.reload
                  issues = Issue.visible(user).all
                  assert issues.any?
                  assert_nil issues.detect {|issue| issue.project_id != 2}
+                 assert_visibility_match user, issues
                end
                def test_visible_scope_for_admin
                  user = User.find(1)
                  user.members.each(&:destroy)
                  assert user.projects.empty?
                  issues = Issue.visible(user).all
                  assert issues.any?
                  # Admin should see issues on private projects that he does not belong to
                  assert issues.detect {|issue| !issue.project.is_public?}
+                 assert_visibility_match user, issues
                end
                def test_visible_scope_with_project
                  project = Project.find(1)
                  issues = Issue.visible(User.find(2), :project => project).all
                  projects = issues.collect(&:project).uniq
                  assert_equal 1, projects.size
                  assert_equal project, projects.first
                end
                def test_visible_scope_with_project_and_subprojects
                  project = Project.find(1)
                  issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all
                  projects = issues.collect(&:project).uniq
                  assert projects.size > 1
                  assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}
                end
                def test_errors_full_messages_should_include_custom_fields_errors
                  field = IssueCustomField.find_by_name('Database')
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field')
                  assert issue.available_custom_fields.include?(field)
                  # Invalid value
                  issue.custom_field_values = { field.id => 'SQLServer' }
                  assert !issue.valid?
                  assert_equal 1, issue.errors.full_messages.size
                  assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}", issue.errors.full_messages.first
                end
                def test_update_issue_with_required_custom_field
                  field = IssueCustomField.find_by_name('Database')
                  field.update_attribute(:is_required, true)
                  issue = Issue.find(1)
                  assert_nil issue.custom_value_for(field)
                  assert issue.available_custom_fields.include?(field)
                  # No change to custom values, issue can be saved
                  assert issue.save
                  # Blank value
                  issue.custom_field_values = { field.id => '' }
                  assert !issue.save
                  # Valid value
                  issue.custom_field_values = { field.id => 'PostgreSQL' }
                  assert issue.save
                  issue.reload
                  assert_equal 'PostgreSQL', issue.custom_value_for(field).value
                end
                def test_should_not_update_attributes_if_custom_fields_validation_fails
                  issue = Issue.find(1)
                  field = IssueCustomField.find_by_name('Database')
                  assert issue.available_custom_fields.include?(field)
                  issue.custom_field_values = { field.id => 'Invalid' }
                  issue.subject = 'Should be not be saved'
                  assert !issue.save
                  issue.reload
                  assert_equal "Can't print recipes", issue.subject
                end
                def test_should_not_recreate_custom_values_objects_on_update
                  field = IssueCustomField.find_by_name('Database')
                  issue = Issue.find(1)
                  issue.custom_field_values = { field.id => 'PostgreSQL' }
                  assert issue.save
                  custom_value = issue.custom_value_for(field)
                  issue.reload
                  issue.custom_field_values = { field.id => 'MySQL' }
                  assert issue.save
                  issue.reload
                  assert_equal custom_value.id, issue.custom_value_for(field).id
                end
                def test_assigning_tracker_id_should_reload_custom_fields_values
                  issue = Issue.new(:project => Project.find(1))
                  assert issue.custom_field_values.empty?
                  issue.tracker_id = 1
                  assert issue.custom_field_values.any?
                end
                def test_assigning_attributes_should_assign_tracker_id_first
                  attributes = ActiveSupport::OrderedHash.new
                  attributes['custom_field_values'] = { '1' => 'MySQL' }
                  attributes['tracker_id'] = '1'
                  issue = Issue.new(:project => Project.find(1))
                  issue.attributes = attributes
                  assert_not_nil issue.custom_value_for(1)
                  assert_equal 'MySQL', issue.custom_value_for(1).value
                end
                def test_should_update_issue_with_disabled_tracker
                  p = Project.find(1)
                  issue = Issue.find(1)
                  p.trackers.delete(issue.tracker)
                  assert !p.trackers.include?(issue.tracker)
                  issue.reload
                  issue.subject = 'New subject'
                  assert issue.save
                end
                def test_should_not_set_a_disabled_tracker
                  p = Project.find(1)
                  p.trackers.delete(Tracker.find(2))
                  issue = Issue.find(1)
                  issue.tracker_id = 2
                  issue.subject = 'New subject'
                  assert !issue.save
                  assert_not_nil issue.errors.on(:tracker_id)
                end
                def test_category_based_assignment
                  issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Assignment test', :description => 'Assignment test', :category_id => 1)
                  assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to
                end
                def test_new_statuses_allowed_to
                  Workflow.delete_all
                  Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false)
                  Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3, :author => true, :assignee => false)
                  Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4, :author => false, :assignee => true)
                  Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 5, :author => true, :assignee => true)
                  status = IssueStatus.find(1)
                  role = Role.find(1)
                  tracker = Tracker.find(1)
                  user = User.find(2)
                  issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1)
                  assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)
                  issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user)
                  assert_equal [1, 2, 3], issue.new_statuses_allowed_to(user).map(&:id)
                  issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :assigned_to => user)
                  assert_equal [1, 2, 4], issue.new_statuses_allowed_to(user).map(&:id)
                  issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user, :assigned_to => user)
                  assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
                end
                def test_copy
                  issue = Issue.new.copy_from(1)
                  assert issue.save
                  issue.reload
                  orig = Issue.find(1)
                  assert_equal orig.subject, issue.subject
                  assert_equal orig.tracker, issue.tracker
                  assert_equal "125", issue.custom_value_for(2).value
                end
                def test_copy_should_copy_status
                  orig = Issue.find(8)
                  assert orig.status != IssueStatus.default
                  issue = Issue.new.copy_from(orig)
                  assert issue.save
                  issue.reload
                  assert_equal orig.status, issue.status
                end
                def test_should_close_duplicates
                  # Create 3 issues
                  issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')
                  assert issue1.save
                  issue2 = issue1.clone
                  assert issue2.save
                  issue3 = issue1.clone
                  assert issue3.save
                  # 2 is a dupe of 1
                  IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # And 3 is a dupe of 2
                  IssueRelation.create(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # And 3 is a dupe of 1 (circular duplicates)
                  IssueRelation.create(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                  assert issue1.reload.duplicates.include?(issue2)
                  # Closing issue 1
                  issue1.init_journal(User.find(:first), "Closing issue1")
                  issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}
                  assert issue1.save
                  # 2 and 3 should be also closed
                  assert issue2.reload.closed?
                  assert issue3.reload.closed?
                end
                def test_should_not_close_duplicated_issue
                  # Create 3 issues
                  issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')
                  assert issue1.save
                  issue2 = issue1.clone
                  assert issue2.save
                  # 2 is a dupe of 1
                  IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # 2 is a dup of 1 but 1 is not a duplicate of 2
                  assert !issue2.reload.duplicates.include?(issue1)
                  # Closing issue 2
                  issue2.init_journal(User.find(:first), "Closing issue2")
                  issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true}
                  assert issue2.save
                  # 1 should not be also closed
                  assert !issue1.reload.closed?
                end
                def test_assignable_versions
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')
                  assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq
                end
                def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')
                  assert !issue.save
                  assert_not_nil issue.errors.on(:fixed_version_id)
                end
                def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 2, :subject => 'New issue')
                  assert !issue.save
                  assert_not_nil issue.errors.on(:fixed_version_id)
                end
                def test_should_be_able_to_assign_a_new_issue_to_an_open_version
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 3, :subject => 'New issue')
                  assert issue.save
                end
                def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version
                  issue = Issue.find(11)
                  assert_equal 'closed', issue.fixed_version.status
                  issue.subject = 'Subject changed'
                  assert issue.save
                end
                def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version
                  issue = Issue.find(11)
                  issue.status_id = 1
                  assert !issue.save
                  assert_not_nil issue.errors.on_base
                end
                def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version
                  issue = Issue.find(11)
                  issue.status_id = 1
                  issue.fixed_version_id = 3
                  assert issue.save
                end
                def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version
                  issue = Issue.find(12)
                  assert_equal 'locked', issue.fixed_version.status
                  issue.status_id = 1
                  assert issue.save
                end
                def test_move_to_another_project_with_same_category
                  issue = Issue.find(1)
                  assert issue.move_to_project(Project.find(2))
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Category changes
                  assert_equal 4, issue.category_id
                  # Make sure time entries were move to the target project
                  assert_equal 2, issue.time_entries.first.project_id
                end
                def test_move_to_another_project_without_same_category
                  issue = Issue.find(2)
                  assert issue.move_to_project(Project.find(2))
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Category cleared
                  assert_nil issue.category_id
                end
                def test_move_to_another_project_should_clear_fixed_version_when_not_shared
                  issue = Issue.find(1)
                  issue.update_attribute(:fixed_version_id, 1)
                  assert issue.move_to_project(Project.find(2))
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Cleared fixed_version
                  assert_equal nil, issue.fixed_version
                end
                def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project
                  issue = Issue.find(1)
                  issue.update_attribute(:fixed_version_id, 4)
                  assert issue.move_to_project(Project.find(5))
                  issue.reload
                  assert_equal 5, issue.project_id
                  # Keep fixed_version
                  assert_equal 4, issue.fixed_version_id
                end
                def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project
                  issue = Issue.find(1)
                  issue.update_attribute(:fixed_version_id, 1)
                  assert issue.move_to_project(Project.find(5))
                  issue.reload
                  assert_equal 5, issue.project_id
                  # Cleared fixed_version
                  assert_equal nil, issue.fixed_version
                end
                def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide
                  issue = Issue.find(1)
                  issue.update_attribute(:fixed_version_id, 7)
                  assert issue.move_to_project(Project.find(2))
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Keep fixed_version
                  assert_equal 7, issue.fixed_version_id
                end
                def test_move_to_another_project_with_disabled_tracker
                  issue = Issue.find(1)
                  target = Project.find(2)
                  target.tracker_ids = [3]
                  target.save
                  assert_equal false, issue.move_to_project(target)
                  issue.reload
                  assert_equal 1, issue.project_id
                end
                def test_copy_to_the_same_project
                  issue = Issue.find(1)
                  copy = nil
                  assert_difference 'Issue.count' do
                    copy = issue.move_to_project(issue.project, nil, :copy => true)
                  end
                  assert_kind_of Issue, copy
                  assert_equal issue.project, copy.project
                  assert_equal "125", copy.custom_value_for(2).value
                end
                def test_copy_to_another_project_and_tracker
                  issue = Issue.find(1)
                  copy = nil
                  assert_difference 'Issue.count' do
                    copy = issue.move_to_project(Project.find(3), Tracker.find(2), :copy => true)
                  end
                  copy.reload
                  assert_kind_of Issue, copy
                  assert_equal Project.find(3), copy.project
                  assert_equal Tracker.find(2), copy.tracker
                  # Custom field #2 is not associated with target tracker
                  assert_nil copy.custom_value_for(2)
                end
                context "#move_to_project" do
                  context "as a copy" do
                    setup do
                      @issue = Issue.find(1)
                      @copy = nil
                    end
                    should "allow assigned_to changes" do
                      @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})
                      assert_equal 3, @copy.assigned_to_id
                    end
                    should "allow status changes" do
                      @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:status_id => 2}})
                      assert_equal 2, @copy.status_id
                    end
                    should "allow start date changes" do
                      date = Date.today
                      @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})
                      assert_equal date, @copy.start_date
                    end
                    should "allow due date changes" do
                      date = Date.today
                      @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:due_date => date}})
                      assert_equal date, @copy.due_date
                    end
                  end
                end
                def test_recipients_should_not_include_users_that_cannot_view_the_issue
                  issue = Issue.find(12)
                  assert issue.recipients.include?(issue.author.mail)
                  # move the issue to a private project
                  copy  = issue.move_to_project(Project.find(5), Tracker.find(2), :copy => true)
                  # author is not a member of project anymore
                  assert !copy.recipients.include?(copy.author.mail)
                end
                def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue
                  user = User.find(3)
                  issue = Issue.find(9)
                  Watcher.create!(:user => user, :watchable => issue)
                  assert issue.watched_by?(user)
                  assert !issue.watcher_recipients.include?(user.mail)
                end
                def test_issue_destroy
                  Issue.find(1).destroy
                  assert_nil Issue.find_by_id(1)
                  assert_nil TimeEntry.find_by_issue_id(1)
                end
                def test_blocked
                  blocked_issue = Issue.find(9)
                  blocking_issue = Issue.find(10)
                  assert blocked_issue.blocked?
                  assert !blocking_issue.blocked?
                end
                def test_blocked_issues_dont_allow_closed_statuses
                  blocked_issue = Issue.find(9)
                  allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002))
                  assert !allowed_statuses.empty?
                  closed_statuses = allowed_statuses.select {|st| st.is_closed?}
                  assert closed_statuses.empty?
                end
                def test_unblocked_issues_allow_closed_statuses
                  blocking_issue = Issue.find(10)
                  allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002))
                  assert !allowed_statuses.empty?
                  closed_statuses = allowed_statuses.select {|st| st.is_closed?}
                  assert !closed_statuses.empty?
                end
                def test_rescheduling_an_issue_should_reschedule_following_issue
                  issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => '-', :start_date => Date.today, :due_date => Date.today + 2)
                  issue2 = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => '-', :start_date => Date.today, :due_date => Date.today + 2)
                  IssueRelation.create!(:issue_from => issue1, :issue_to => issue2, :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert_equal issue1.due_date + 1, issue2.reload.start_date
                  issue1.due_date = Date.today + 5
                  issue1.save!
                  assert_equal issue1.due_date + 1, issue2.reload.start_date
                end
                def test_overdue
                  assert Issue.new(:due_date => 1.day.ago.to_date).overdue?
                  assert !Issue.new(:due_date => Date.today).overdue?
                  assert !Issue.new(:due_date => 1.day.from_now.to_date).overdue?
                  assert !Issue.new(:due_date => nil).overdue?
                  assert !Issue.new(:due_date => 1.day.ago.to_date, :status => IssueStatus.find(:first, :conditions => {:is_closed => true})).overdue?
                end
                context "#behind_schedule?" do
                  should "be false if the issue has no start_date" do
                    assert !Issue.new(:start_date => nil, :due_date => 1.day.from_now.to_date, :done_ratio => 0).behind_schedule?
                  end
                  should "be false if the issue has no end_date" do
                    assert !Issue.new(:start_date => 1.day.from_now.to_date, :due_date => nil, :done_ratio => 0).behind_schedule?
                  end
                  should "be false if the issue has more done than it's calendar time" do
                    assert !Issue.new(:start_date => 50.days.ago.to_date, :due_date => 50.days.from_now.to_date, :done_ratio => 90).behind_schedule?
                  end
                  should "be true if the issue hasn't been started at all" do
                    assert Issue.new(:start_date => 1.day.ago.to_date, :due_date => 1.day.from_now.to_date, :done_ratio => 0).behind_schedule?
                  end
                  should "be true if the issue has used more calendar time than it's done ratio" do
                    assert Issue.new(:start_date => 100.days.ago.to_date, :due_date => Date.today, :done_ratio => 90).behind_schedule?
                  end
                end
                context "#assignable_users" do
                  should "be Users" do
                    assert_kind_of User, Issue.find(1).assignable_users.first
                  end
                  should "include the issue author" do
                    project = Project.find(1)
                    non_project_member = User.generate!
                    issue = Issue.generate_for_project!(project, :author => non_project_member)
                    assert issue.assignable_users.include?(non_project_member)
                  end
                  should "not show the issue author twice" do
                    assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)
                    assert_equal 2, assignable_user_ids.length
                    assignable_user_ids.each do |user_id|
                      assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length, "User #{user_id} appears more or less than once"
                    end
                  end
                end
                def test_create_should_send_email_notification
                  ActionMailer::Base.deliveries.clear
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create', :estimated_hours => '1:30')
                  assert issue.save
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_stale_issue_should_not_send_email_notification
                  ActionMailer::Base.deliveries.clear
                  issue = Issue.find(1)
                  stale = Issue.find(1)
                  issue.init_journal(User.find(1))
                  issue.subject = 'Subjet update'
                  assert issue.save
                  assert_equal 1, ActionMailer::Base.deliveries.size
                  ActionMailer::Base.deliveries.clear
                  stale.init_journal(User.find(1))
                  stale.subject = 'Another subjet update'
                  assert_raise ActiveRecord::StaleObjectError do
                    stale.save
                  end
                  assert ActionMailer::Base.deliveries.empty?
                end
                def test_journalized_description
                  IssueCustomField.delete_all
                  i = Issue.first
                  old_description = i.description
                  new_description = "This is the new description"
                  i.init_journal(User.find(2))
                  i.description = new_description
                  assert_difference 'Journal.count', 1 do
                    assert_difference 'JournalDetail.count', 1 do
                      i.save!
                    end
                  end
                  detail = JournalDetail.first(:order => 'id DESC')
                  assert_equal i, detail.journal.journalized
                  assert_equal 'attr', detail.property
                  assert_equal 'description', detail.prop_key
                  assert_equal old_description, detail.old_value
                  assert_equal new_description, detail.value
                end
                def test_saving_twice_should_not_duplicate_journal_details
                  i = Issue.find(:first)
                  i.init_journal(User.find(2), 'Some notes')
                  # initial changes
                  i.subject = 'New subject'
                  i.done_ratio = i.done_ratio + 10
                  assert_difference 'Journal.count' do
                    assert i.save
                  end
                  # 1 more change
                  i.priority = IssuePriority.find(:first, :conditions => ["id <> ?", i.priority_id])
                  assert_no_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count', 1 do
                      i.save
                    end
                  end
                  # no more change
                  assert_no_difference 'Journal.count' do
                    assert_no_difference 'JournalDetail.count' do
                      i.save
                    end
                  end
                end
                def test_all_dependent_issues
                  IssueRelation.delete_all
                  assert IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert IssueRelation.create!(:issue_from => Issue.find(3), :issue_to => Issue.find(8), :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
                end
                def test_all_dependent_issues_with_persistent_circular_dependency
                  IssueRelation.delete_all
                  assert IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES)
                  # Validation skipping
                  assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_PRECEDES).save(false)
                  assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort
                end
                def test_all_dependent_issues_with_persistent_multiple_circular_dependencies
                  IssueRelation.delete_all
                  assert IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_RELATES)
                  assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_RELATES)
                  assert IssueRelation.create!(:issue_from => Issue.find(3), :issue_to => Issue.find(8), :relation_type => IssueRelation::TYPE_RELATES)
                  # Validation skipping
                  assert IssueRelation.new(:issue_from => Issue.find(8), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_RELATES).save(false)
                  assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_RELATES).save(false)
                  assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
                end
                context "#done_ratio" do
                  setup do
                    @issue = Issue.find(1)
                    @issue_status = IssueStatus.find(1)
                    @issue_status.update_attribute(:default_done_ratio, 50)
                    @issue2 = Issue.find(2)
                    @issue_status2 = IssueStatus.find(2)
                    @issue_status2.update_attribute(:default_done_ratio, 0)
                  end
                  context "with Setting.issue_done_ratio using the issue_field" do
                    setup do
                      Setting.issue_done_ratio = 'issue_field'
                    end
                    should "read the issue's field" do
                      assert_equal 0, @issue.done_ratio
                      assert_equal 30, @issue2.done_ratio
                    end
                  end
                  context "with Setting.issue_done_ratio using the issue_status" do
                    setup do
                      Setting.issue_done_ratio = 'issue_status'
                    end
                    should "read the Issue Status's default done ratio" do
                      assert_equal 50, @issue.done_ratio
                      assert_equal 0, @issue2.done_ratio
                    end
                  end
                end
                context "#update_done_ratio_from_issue_status" do
                  setup do
                    @issue = Issue.find(1)
                    @issue_status = IssueStatus.find(1)
                    @issue_status.update_attribute(:default_done_ratio, 50)
                    @issue2 = Issue.find(2)
                    @issue_status2 = IssueStatus.find(2)
                    @issue_status2.update_attribute(:default_done_ratio, 0)
                  end
                  context "with Setting.issue_done_ratio using the issue_field" do
                    setup do
                      Setting.issue_done_ratio = 'issue_field'
                    end
                    should "not change the issue" do
                      @issue.update_done_ratio_from_issue_status
                      @issue2.update_done_ratio_from_issue_status
                      assert_equal 0, @issue.read_attribute(:done_ratio)
                      assert_equal 30, @issue2.read_attribute(:done_ratio)
                    end
                  end
                  context "with Setting.issue_done_ratio using the issue_status" do
                    setup do
                      Setting.issue_done_ratio = 'issue_status'
                    end
                    should "change the issue's done ratio" do
                      @issue.update_done_ratio_from_issue_status
                      @issue2.update_done_ratio_from_issue_status
                      assert_equal 50, @issue.read_attribute(:done_ratio)
                      assert_equal 0, @issue2.read_attribute(:done_ratio)
                    end
                  end
                end
                test "#by_tracker" do
                  User.current = User.anonymous
                  groups = Issue.by_tracker(Project.find(1))
                  assert_equal 3, groups.size
                  assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_version" do
                  User.current = User.anonymous
                  groups = Issue.by_version(Project.find(1))
                  assert_equal 3, groups.size
                  assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_priority" do
                  User.current = User.anonymous
                  groups = Issue.by_priority(Project.find(1))
                  assert_equal 4, groups.size
                  assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_category" do
                  User.current = User.anonymous
                  groups = Issue.by_category(Project.find(1))
                  assert_equal 2, groups.size
                  assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_assigned_to" do
                  User.current = User.anonymous
                  groups = Issue.by_assigned_to(Project.find(1))
                  assert_equal 2, groups.size
                  assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_author" do
                  User.current = User.anonymous
                  groups = Issue.by_author(Project.find(1))
                  assert_equal 4, groups.size
                  assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_subproject" do
                  User.current = User.anonymous
                  groups = Issue.by_subproject(Project.find(1))
                  # Private descendant not visible
                  assert_equal 1, groups.size
                  assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                context ".allowed_target_projects_on_move" do
                  should "return all active projects for admin users" do
                    User.current = User.find(1)
                    assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size
                  end
                  should "return allowed projects for non admin users" do
                    User.current = User.find(2)
                    Role.non_member.remove_permission! :move_issues
                    assert_equal 3, Issue.allowed_target_projects_on_move.size
                    Role.non_member.add_permission! :move_issues
                    assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size
                  end
                end
                def test_recently_updated_with_limit_scopes
                  #should return the last updated issue
                  assert_equal 1, Issue.recently_updated.with_limit(1).length
                  assert_equal Issue.find(:first, :order => "updated_on DESC"), Issue.recently_updated.with_limit(1).first
                end
                def test_on_active_projects_scope
                  assert Project.find(2).archive
                  before = Issue.on_active_project.length
                  # test inclusion to results
                  issue = Issue.generate_for_project!(Project.find(1), :tracker => Project.find(2).trackers.first)
                  assert_equal before + 1, Issue.on_active_project.length
                  # Move to an archived project
                  issue.project = Project.find(2)
                  assert issue.save
                  assert_equal before, Issue.on_active_project.length
                end
                context "Issue#recipients" do
                  setup do
                    @project = Project.find(1)
                    @author = User.generate_with_protected!
                    @assignee = User.generate_with_protected!
                    @issue = Issue.generate_for_project!(@project, :assigned_to => @assignee, :author => @author)
                  end
                  should "include project recipients" do
                    assert @project.recipients.present?
                    @project.recipients.each do |project_recipient|
                      assert @issue.recipients.include?(project_recipient)
                    end
                  end
                  should "include the author if the author is active" do
                    assert @issue.author, "No author set for Issue"
                    assert @issue.recipients.include?(@issue.author.mail)
                  end
                  should "include the assigned to user if the assigned to user is active" do
                    assert @issue.assigned_to, "No assigned_to set for Issue"
                    assert @issue.recipients.include?(@issue.assigned_to.mail)
                  end
                  should "not include users who opt out of all email" do
                    @author.update_attribute(:mail_notification, :none)
                    assert !@issue.recipients.include?(@issue.author.mail)
                  end
                  should "not include the issue author if they are only notified of assigned issues" do
                    @author.update_attribute(:mail_notification, :only_assigned)
                    assert !@issue.recipients.include?(@issue.author.mail)
                  end
                  should "not include the assigned user if they are only notified of owned issues" do
                    @assignee.update_attribute(:mail_notification, :only_owner)
                    assert !@issue.recipients.include?(@issue.assigned_to.mail)
                  end
                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