jro_apps/redmine Commit - r13882:51f7060aa846

Add the ability to expire passwords after a configurable number of days (#19458)....

Jean-Philippe Lang -

r13882:51f7060aa846

parent child

Context file:

r13882:51f7060aa846

Collapse all files

app/controllers/application_controller.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 Unauthorized < Exception; end
             class ApplicationController < ActionController::Base
               include Redmine::I18n
               include Redmine::Pagination
               include RoutesHelper
               helper :routes
               class_attribute :accept_api_auth_actions
               class_attribute :accept_rss_auth_actions
               class_attribute :model_object
               layout 'base'
               protect_from_forgery
               def verify_authenticity_token
                 unless api_request?
                   super
                 end
               end
               def handle_unverified_request
                 unless api_request?
                   super
                   cookies.delete(autologin_cookie_name)
                   self.logged_user = nil
                   set_localization
                   render_error :status => 422, :message => "Invalid form authenticity token."
                 end
               end
               before_filter :session_expiration, :user_setup, :force_logout_if_password_changed, :check_if_login_required, :check_password_change, :set_localization
               rescue_from ::Unauthorized, :with => :deny_access
               rescue_from ::ActionView::MissingTemplate, :with => :missing_template
               include Redmine::Search::Controller
               include Redmine::MenuManager::MenuController
               helper Redmine::MenuManager::MenuHelper
               def session_expiration
                 if session[:user_id]
                   if session_expired? && !try_to_autologin
                     set_localization(User.active.find_by_id(session[:user_id]))
                     self.logged_user = nil
                     flash[:error] = l(:error_session_expired)
                     require_login
                   else
                     session[:atime] = Time.now.utc.to_i
                   end
                 end
               end
               def session_expired?
                 if Setting.session_lifetime?
                   unless session[:ctime] && (Time.now.utc.to_i - session[:ctime].to_i <= Setting.session_lifetime.to_i * 60)
                     return true
                   end
                 end
                 if Setting.session_timeout?
                   unless session[:atime] && (Time.now.utc.to_i - session[:atime].to_i <= Setting.session_timeout.to_i * 60)
                     return true
                   end
                 end
                 false
               end
               def start_user_session(user)
                 session[:user_id] = user.id
                 session[:ctime] = Time.now.utc.to_i
                 session[:atime] = Time.now.utc.to_i
                 if user.must_change_password?
                   session[:pwd] = '1'
                 end
               end
               def user_setup
                 # Check the settings cache for each request
                 Setting.check_cache
                 # Find the current user
                 User.current = find_current_user
                 logger.info("  Current user: " + (User.current.logged? ? "#{User.current.login} (id=#{User.current.id})" : "anonymous")) if logger
               end
               # Returns the current user or nil if no user is logged in
               # and starts a session if needed
               def find_current_user
                 user = nil
                 unless api_request?
                   if session[:user_id]
                     # existing session
                     user = (User.active.find(session[:user_id]) rescue nil)
                   elsif autologin_user = try_to_autologin
                     user = autologin_user
                   elsif params[:format] == 'atom' && params[:key] && request.get? && accept_rss_auth?
                     # RSS key authentication does not start a session
                     user = User.find_by_rss_key(params[:key])
                   end
                 end
                 if user.nil? && Setting.rest_api_enabled? && accept_api_auth?
                   if (key = api_key_from_request)
                     # Use API key
                     user = User.find_by_api_key(key)
                   elsif request.authorization.to_s =~ /\ABasic /i
                     # HTTP Basic, either username/password or API key/random
                     authenticate_with_http_basic do |username, password|
                       user = User.try_to_login(username, password) || User.find_by_api_key(username)
                     end
                     if user && user.must_change_password?
                       render_error :message => 'You must change your password', :status => 403
                       return
                     end
                   end
                   # Switch user if requested by an admin user
                   if user && user.admin? && (username = api_switch_user_from_request)
                     su = User.find_by_login(username)
                     if su && su.active?
                       logger.info("  User switched by: #{user.login} (id=#{user.id})") if logger
                       user = su
                     else
                       render_error :message => 'Invalid X-Redmine-Switch-User header', :status => 412
                     end
                   end
                 end
                 user
               end
               def force_logout_if_password_changed
                 passwd_changed_on = User.current.passwd_changed_on || Time.at(0)
                 # Make sure we force logout only for web browser sessions, not API calls
                 # if the password was changed after the session creation.
                 if session[:user_id] && passwd_changed_on.utc.to_i > session[:ctime].to_i
                   reset_session
                   set_localization
                   flash[:error] = l(:error_session_expired)
                   redirect_to signin_url
                 end
               end
               def autologin_cookie_name
                 Redmine::Configuration['autologin_cookie_name'].presence || 'autologin'
               end
               def try_to_autologin
                 if cookies[autologin_cookie_name] && Setting.autologin?
                   # auto-login feature starts a new session
                   user = User.try_to_autologin(cookies[autologin_cookie_name])
                   if user
                     reset_session
                     start_user_session(user)
                   end
                   user
                 end
               end
               # Sets the logged in user
               def logged_user=(user)
                 reset_session
                 if user && user.is_a?(User)
                   User.current = user
                   start_user_session(user)
                 else
                   User.current = User.anonymous
                 end
               end
               # Logs out current user
               def logout_user
                 if User.current.logged?
                   cookies.delete(autologin_cookie_name)
                   Token.delete_all(["user_id = ? AND action = ?", User.current.id, 'autologin'])
                   self.logged_user = nil
                 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 check_password_change
                 if session[:pwd]
                   if User.current.must_change_password?
+                    flash[:error] = l(:error_password_expired)
                     redirect_to my_password_path
                   else
                     session.delete(:pwd)
                   end
                 end
               end
               def set_localization(user=User.current)
                 lang = nil
                 if user && user.logged?
                   lang = find_language(user.language)
                 end
                 if lang.nil? && !Setting.force_default_language_for_anonymous? && 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 {
                       if request.xhr?
                         head :unauthorized
                       else
                         redirect_to signin_path(:back_url => url)
                       end
                     }
                     format.any(:atom, :pdf, :csv) {
                       redirect_to signin_path(: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"' }
                     format.any  { head :unauthorized }
                   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
               end
               def find_model_object
                 model = self.class.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)
                 self.model_object = model
               end
               # Find the issue whose id is the :id parameter
               # Raises a Unauthorized exception if the issue is not visible
               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])
                 raise Unauthorized unless @issue.visible?
                 @project = @issue.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Find issues with a single :id param or :ids array param
               # Raises a Unauthorized exception if one of the issues is not visible
               def find_issues
                 @issues = Issue.where(:id => (params[:id] || params[:ids])).preload(:project, :status, :tracker, :priority, :author, :assigned_to, :relations_to).to_a
                 raise ActiveRecord::RecordNotFound if @issues.empty?
                 raise Unauthorized unless @issues.all?(&:visible?)
                 @projects = @issues.collect(&:project).compact.uniq
                 @project = @projects.first if @projects.size == 1
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_attachments
                 if (attachments = params[:attachments]).present?
                   att = attachments.values.collect do |attachment|
                     Attachment.find_by_token( attachment[:token] ) if attachment[:token].present?
                   end
                   att.compact!
                 end
                 @attachments = att || []
               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.archived?
                   if @project.visible?
                     true
                   else
                     deny_access
                   end
                 else
                   @project = nil
                   render_404
                   false
                 end
               end
               def back_url
                 url = params[:back_url]
                 if url.nil? && referer = request.env['HTTP_REFERER']
                   url = CGI.unescape(referer.to_s)
                 end
                 url
               end
               def redirect_back_or_default(default, options={})
                 back_url = params[:back_url].to_s
                 if back_url.present? && valid_back_url?(back_url)
                   redirect_to(back_url)
                   return
                 elsif options[:referer]
                   redirect_to_referer_or default
                   return
                 end
                 redirect_to default
                 false
               end
               # Returns true if back_url is a valid url for redirection, otherwise false
               def valid_back_url?(back_url)
                 if CGI.unescape(back_url).include?('..')
                   return false
                 end
                 begin
                   uri = URI.parse(back_url)
                 rescue URI::InvalidURIError
                   return false
                 end
                 if uri.host.present? && uri.host != request.host
                   return false
                 end
                 if uri.path.match(%r{/(login|account/register)})
                   return false
                 end
                 if relative_url_root.present? && !uri.path.starts_with?(relative_url_root)
                   return false
                 end
                 return true
               end
               private :valid_back_url?
               # Redirects to the request referer if present, redirects to args or call block otherwise.
               def redirect_to_referer_or(*args, &block)
                 redirect_to :back
               rescue ::ActionController::RedirectBackError
                 if args.any?
                   redirect_to *args
                 elsif block_given?
                   block.call
                 else
                   raise "#redirect_to_referer_or takes arguments or a block"
                 end
               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.any { head @status }
                 end
               end
               # Handler for ActionView::MissingTemplate exception
               def missing_template
                 logger.warn "Missing template, responding with 404"
                 @project = nil
                 render_404
               end
               # Filter for actions that provide an API response
               # but have no HTML representation for non admin users
               def require_admin_or_api_request
                 return true if api_request?
                 if User.current.admin?
                   true
                 elsif User.current.logged?
                   render_error(:status => 406)
                 else
                   deny_access
                 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 render_feed(items, options={})
                 @items = (items || []).to_a
                 @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", :formats => [:atom], :layout => false,
                        :content_type => 'application/atom+xml'
               end
               def self.accept_rss_auth(*actions)
                 if actions.any?
                   self.accept_rss_auth_actions = actions
                 else
                   self.accept_rss_auth_actions || []
                 end
               end
               def accept_rss_auth?(action=action_name)
                 self.class.accept_rss_auth.include?(action.to_sym)
               end
               def self.accept_api_auth(*actions)
                 if actions.any?
                   self.accept_api_auth_actions = actions
                 else
                   self.accept_api_auth_actions || []
                 end
               end
               def accept_api_auth?(action=action_name)
                 self.class.accept_api_auth.include?(action.to_sym)
               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|Trident)} ? 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].to_s
                 elsif request.headers["X-Redmine-API-Key"].present?
                   request.headers["X-Redmine-API-Key"].to_s
                 end
               end
               # Returns the API 'switch user' value if present
               def api_switch_user_from_request
                 request.headers["X-Redmine-Switch-User"].to_s.presence
               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
               # 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
               # Renders a 200 response for successfull updates or deletions via the API
               def render_api_ok
                 render_api_head :ok
               end
               # Renders a head API response
               def render_api_head(status)
                 # #head would return a response body with one space
                 render :text => '', :status => status, :layout => nil
               end
               # Renders API response on validation failure
               # for an object or an array of objects
               def render_validation_errors(objects)
                 messages = Array.wrap(objects).map {|object| object.errors.full_messages}.flatten
                 render_api_errors(messages)
               end
               def render_api_errors(*messages)
                 @error_messages = messages.flatten
                 render :template => 'common/error_messages.api', :status => :unprocessable_entity, :layout => nil
               end
               # Overrides #_include_layout? so that #render with no arguments
               # doesn't use the layout for api requests
               def _include_layout?(*args)
                 api_request? ? false : super
               end
             end

app/models/user.rb +12 -1

             # Redmine - project management software
             # Copyright (C) 2006-2015  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
               # Different ways of displaying/sorting users
               USER_FORMATS = {
                 :firstname_lastname => {
                     :string => '#{firstname} #{lastname}',
                     :order => %w(firstname lastname id),
                     :setting_order => 1
                   },
                 :firstname_lastinitial => {
                     :string => '#{firstname} #{lastname.to_s.chars.first}.',
                     :order => %w(firstname lastname id),
                     :setting_order => 2
                   },
                 :firstinitial_lastname => {
                     :string => '#{firstname.to_s.gsub(/(([[:alpha:]])[[:alpha:]]*\.?)/, \'\2.\')} #{lastname}',
                     :order => %w(firstname lastname id),
                     :setting_order => 2
                   },
                 :firstname => {
                     :string => '#{firstname}',
                     :order => %w(firstname id),
                     :setting_order => 3
                   },
                 :lastname_firstname => {
                     :string => '#{lastname} #{firstname}',
                     :order => %w(lastname firstname id),
                     :setting_order => 4
                   },
                 :lastname_coma_firstname => {
                     :string => '#{lastname}, #{firstname}',
                     :order => %w(lastname firstname id),
                     :setting_order => 5
                   },
                 :lastname => {
                     :string => '#{lastname}',
                     :order => %w(lastname id),
                     :setting_order => 6
                   },
                 :username => {
                     :string => '#{login}',
                     :order => %w(login id),
                     :setting_order => 7
                   },
               }
               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,
                                       :join_table   => "#{table_name_prefix}groups_users#{table_name_suffix}",
                                       :after_add    => Proc.new {|user, group| group.user_added(user)},
                                       :after_remove => Proc.new {|user, group| group.user_removed(user)}
               has_many :changesets, :dependent => :nullify
               has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
               has_one :rss_token, lambda {where "action='feeds'"}, :class_name => 'Token'
               has_one :api_token, lambda {where "action='api'"}, :class_name => 'Token'
               has_one :email_address, lambda {where :is_default => true}, :autosave => true
               has_many :email_addresses, :dependent => :delete_all
               belongs_to :auth_source
               scope :logged, lambda { where("#{User.table_name}.status <> #{STATUS_ANONYMOUS}") }
               scope :status, lambda {|arg| where(arg.blank? ? nil : {:status => arg.to_i}) }
               acts_as_customizable
               attr_accessor :password, :password_confirmation, :generate_password
               attr_accessor :last_before_login_on
               # Prevents unauthorized assignments
               attr_protected :login, :admin, :password, :password_confirmation, :hashed_password
               LOGIN_LENGTH_LIMIT = 60
               MAIL_LENGTH_LIMIT = 60
               validates_presence_of :login, :firstname, :lastname, :if => Proc.new { |user| !user.is_a?(AnonymousUser) }
               validates_uniqueness_of :login, :if => Proc.new { |user| user.login_changed? && user.login.present? }, :case_sensitive => false
               # Login must contain letters, numbers, underscores only
               validates_format_of :login, :with => /\A[a-z0-9_\-@\.]*\z/i
               validates_length_of :login, :maximum => LOGIN_LENGTH_LIMIT
               validates_length_of :firstname, :lastname, :maximum => 30
               validates_inclusion_of :mail_notification, :in => MAIL_NOTIFICATION_OPTIONS.collect(&:first), :allow_blank => true
               validate :validate_password_length
               validate do
                 if password_confirmation && password != password_confirmation
                   errors.add(:password, :confirmation)
                 end
               end
               before_validation :instantiate_email_address
               before_create :set_mail_notification
               before_save   :generate_password_if_needed, :update_hashed_password
               before_destroy :remove_references_before_destroy
               after_save :update_notified_project_ids, :destroy_tokens
               scope :in_group, lambda {|group|
                 group_id = group.is_a?(Group) ? group.id : group.to_i
                 where("#{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)
               }
               scope :not_in_group, lambda {|group|
                 group_id = group.is_a?(Group) ? group.id : group.to_i
                 where("#{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)
               }
               scope :sorted, lambda { order(*User.fields_for_order_statement)}
               scope :having_mail, lambda {|arg|
                 addresses = Array.wrap(arg).map {|a| a.to_s.downcase}
                 if addresses.any?
                   joins(:email_addresses).where("LOWER(address) IN (?)", addresses).uniq
                 else
                   none
                 end
               }
               def set_mail_notification
                 self.mail_notification = Setting.default_notification_option if self.mail_notification.blank?
                 true
               end
               def update_hashed_password
                 # update hashed_password if password was set
                 if self.password && self.auth_source_id.blank?
                   salt_password(password)
                 end
               end
               alias :base_reload :reload
               def reload(*args)
                 @name = nil
                 @projects_by_role = nil
                 @membership_by_project_id = nil
                 @notified_projects_ids = nil
                 @notified_projects_ids_changed = false
                 @builtin_role = nil
                 @visible_project_ids = nil
                 base_reload(*args)
               end
               def mail
                 email_address.try(:address)
               end
               def mail=(arg)
                 email = email_address || build_email_address
                 email.address = arg
               end
               def mail_changed?
                 email_address.try(:address_changed?)
               end
               def mails
                 email_addresses.pluck(:address)
               end
               def self.find_or_initialize_by_identity_url(url)
                 user = where(:identity_url => url).first
                 unless user
                   user = User.new
                   user.identity_url = url
                 end
                 user
               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
                     # Invalid 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, active_only=true)
                 login = login.to_s
                 password = password.to_s
                 # Make sure no one can sign in with an empty login or password
                 return nil if login.empty? || password.empty?
                 user = find_by_login(login)
                 if user
                   # user is already in local database
                   return nil unless user.check_password?(password)
                   return nil if !user.active? && active_only
                 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_column(:last_login_on, Time.now) if user && !user.new_record? && user.active?
                 user
               rescue => text
                 raise text
               end
               # Returns the user who matches the given autologin +key+ or nil
               def self.try_to_autologin(key)
                 user = Token.find_active_user('autologin', key, Setting.autologin.to_i)
                 if user
                   user.update_column(:last_login_on, Time.now)
                   user
                 end
               end
               def self.name_formatter(formatter = nil)
                 USER_FORMATS[formatter || Setting.user_format] || USER_FORMATS[:firstname_lastname]
               end
               # Returns an array of fields names than can be used to make an order statement for users
               # according to how user names are displayed
               # Examples:
               #
               #   User.fields_for_order_statement              => ['users.login', 'users.id']
               #   User.fields_for_order_statement('authors')   => ['authors.login', 'authors.id']
               def self.fields_for_order_statement(table=nil)
                 table ||= table_name
                 name_formatter[:order].map {|field| "#{table}.#{field}"}
               end
               # Return user's full name for display
               def name(formatter = nil)
                 f = self.class.name_formatter(formatter)
                 if formatter
                   eval('"' + f[:string] + '"')
                 else
                   @name ||= eval('"' + f[:string] + '"')
                 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}")
                 self.passwd_changed_on = Time.now.change(:usec => 0)
               end
               # Does the backend storage allow this user to change their password?
               def change_password_allowed?
                 return true if auth_source.nil?
                 return auth_source.allow_password_changes?
               end
+              def password_expired?
+                changed_on = self.passwd_changed_on || Time.at(0)
+                period = Setting.password_max_age.to_i
+                if period.zero?
+                  false
+                else
+                  changed_on < period.days.ago
+                end
+              end
               def must_change_password?
-                must_change_passwd? && change_password_allowed?
+                (must_change_passwd? || password_expired?) && change_password_allowed?
               end
               def generate_password?
                 generate_password == '1' || generate_password == true
               end
               # Generate and set a random password on given length
               def random_password(length=40)
                 chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
                 chars -= %w(0 O 1 l)
                 password = ''
                 length.times {|i| password << chars[SecureRandom.random_number(chars.size)] }
                 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 force_default_language?
                 Setting.force_default_language_for_loggedin?
               end
               def language
                 if force_default_language?
                   Setting.default_language
                 else
                   super
                 end
               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
                 if rss_token.nil?
                   create_rss_token(:action => 'feeds')
                 end
                 rss_token.value
               end
               # Return user's API key (a 40 chars long string), used to access the API
               def api_key
                 if api_token.nil?
                   create_api_token(:action => 'api')
                 end
                 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)
                 @notified_projects_ids_changed = true
                 @notified_projects_ids = ids.map(&:to_i).uniq.select {|n| n > 0}
               end
               # Updates per project notifications (after_save callback)
               def update_notified_project_ids
                 if @notified_projects_ids_changed
                   ids = (mail_notification == 'selected' ? Array.wrap(notified_projects_ids).reject(&:blank?) : [])
                   members.update_all(:mail_notification => false)
                   members.where(:project_id => ids).update_all(:mail_notification => true) if ids.any?
                 end
               end
               private :update_notified_project_ids
               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)
                 login = Redmine::CodesetUtil.replace_invalid_utf8(login.to_s)
                 if login.present?
                   # First look for an exact match
                   user = where(:login => login).detect {|u| u.login == login}
                   unless user
                     # Fail over to case-insensitive if none was found
                     user = where("LOWER(login) = ?", login.downcase).first
                   end
                   user
                 end
               end
               def self.find_by_rss_key(key)
                 Token.find_active_user('feeds', key)
               end
               def self.find_by_api_key(key)
                 Token.find_active_user('api', key)
               end
               # Makes find_by_mail case-insensitive
               def self.find_by_mail(mail)
                 having_mail(mail).first
               end
               # Returns true if the default admin account can no longer be used
               def self.default_admin_account_changed?
                 !User.active.find_by_login("admin").try(:check_password?, "admin")
               end
               def to_s
                 name
               end
               CSS_CLASS_BY_STATUS = {
                 STATUS_ANONYMOUS  => 'anon',
                 STATUS_ACTIVE     => 'active',
                 STATUS_REGISTERED => 'registered',
                 STATUS_LOCKED     => 'locked'
               }
               def css_classes
                 "user #{CSS_CLASS_BY_STATUS[status]}"
               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
               # Returns the day of +time+ according to user's time zone
               def time_to_date(time)
                 if time_zone.nil?
                   time.to_date
                 else
                   time.in_time_zone(time_zone).to_date
                 end
               end
               def logged?
                 true
               end
               def anonymous?
                 !logged?
               end
               # Returns user's membership for the given project
               # or nil if the user is not a member of project
               def membership(project)
                 project_id = project.is_a?(Project) ? project.id : project
                 @membership_by_project_id ||= Hash.new {|h, project_id|
                   h[project_id] = memberships.where(:project_id => project_id).first
                 }
                 @membership_by_project_id[project_id]
               end
               # Returns the user's bult-in role
               def builtin_role
                 @builtin_role ||= Role.non_member
               end
               # Return user's roles for project
               def roles_for_project(project)
                 # No role on archived projects
                 return [] if project.nil? || project.archived?
                 if membership = membership(project)
                   membership.roles.dup
                 elsif project.is_public?
                   project.override_roles(builtin_role)
                 else
                   []
                 end
               end
               # Returns a hash of user's projects grouped by roles
               def projects_by_role
                 return @projects_by_role if @projects_by_role
                 hash = Hash.new([])
                 group_class = anonymous? ? GroupAnonymous : GroupNonMember
                 members = Member.joins(:project, :principal).
                   where("#{Project.table_name}.status <> 9").
                   where("#{Member.table_name}.user_id = ? OR (#{Project.table_name}.is_public = ? AND #{Principal.table_name}.type = ?)", self.id, true, group_class.name).
                   preload(:project, :roles).
                   to_a
                 members.reject! {|member| member.user_id != id && project_ids.include?(member.project_id)}
                 members.each do |member|
                   if member.project
                     member.roles.each do |role|
                       hash[role] = [] unless hash.key?(role)
                       hash[role] << member.project
                     end
                   end
                 end
                 hash.each do |role, projects|
                   projects.uniq!
                 end
                 @projects_by_role = hash
               end
               # Returns the ids of visible projects
               def visible_project_ids
                 @visible_project_ids ||= Project.visible(self).pluck(:id)
               end
               # Returns true if user is arg or belongs to arg
               def is_or_belongs_to?(arg)
                 if arg.is_a?(User)
                   self == arg
                 elsif arg.is_a?(Group)
                   arg.users.include?(self)
                 else
                   false
                 end
               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
               # * 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={}, &block)
                 if context && context.is_a?(Project)
                   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.any? {|role|
                     (context.is_public? || role.member?) &&
                     role.allowed_to?(action) &&
                     (block_given? ? yield(role, self) : true)
                   }
                 elsif context && context.is_a?(Array)
                   if context.empty?
                     false
                   else
                     # Authorize if user is authorized on every element of the array
                     context.map {|project| allowed_to?(action, project, options, &block)}.reduce(:&)
                   end
                 elsif context
                   raise ArgumentError.new("#allowed_to? context argument must be a Project, an Array of projects or nil")
                 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 << (self.logged? ? Role.non_member : Role.anonymous)
                   roles.any? {|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.
               #
               # NB: this method is not used anywhere in the core codebase as of
               # 2.5.2, but it's used by many plugins so if we ever want to remove
               # it it has to be carefully deprecated for a version or two.
               def allowed_to_globally?(action, options={}, &block)
                 allowed_to?(action, nil, options.reverse_merge(:global => true), &block)
               end
               # Returns true if the user is allowed to delete the user's own account
               def own_account_deletable?
                 Setting.unsubscribe? &&
                   (!admin? || User.active.where("admin = ? AND id <> ?", true, id).exists?)
               end
               safe_attributes 'login',
                 'firstname',
                 'lastname',
                 'mail',
                 'mail_notification',
                 'notified_project_ids',
                 'language',
                 'custom_field_values',
                 'custom_fields',
                 'identity_url'
               safe_attributes 'status',
                 'auth_source_id',
                 'generate_password',
                 'must_change_passwd',
                 :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)
                 if mail_notification == 'all'
                   true
                 elsif mail_notification.blank? || mail_notification == 'none'
                   false
                 else
                   case object
                   when Issue
                     case mail_notification
                     when 'selected', 'only_my_events'
                       # user receives notifications for created/assigned issues on unselected projects
                       object.author == self || is_or_belongs_to?(object.assigned_to) || is_or_belongs_to?(object.assigned_to_was)
                     when 'only_assigned'
                       is_or_belongs_to?(object.assigned_to) || is_or_belongs_to?(object.assigned_to_was)
                     when 'only_owner'
                       object.author == self
                     end
                   when News
                     # always send to project members except when mail_notification is set to 'none'
                     true
                   end
                 end
               end
               def self.current=(user)
                 RequestStore.store[:current_user] = user
               end
               def self.current
                 RequestStore.store[: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.first
                 if anonymous_user.nil?
                   anonymous_user = AnonymousUser.create(:lastname => 'Anonymous', :firstname => '', :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.where("salt IS NULL OR salt = ''").find_each do |user|
                     next if user.hashed_password.blank?
                     salt = User.generate_salt
                     hashed_password = User.hash_password("#{salt}#{user.hashed_password}")
                     User.where(:id => user.id).update_all(:salt => salt, :hashed_password => hashed_password)
                   end
                 end
               end
               protected
               def validate_password_length
                 return if password.blank? && generate_password?
                 # 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
               def instantiate_email_address
                 email_address || build_email_address
               end
               private
               def generate_password_if_needed
                 if generate_password? && auth_source.nil?
                   length = [Setting.password_min_length.to_i + 2, 10].max
                   random_password(length)
                 end
               end
               # Delete all outstanding password reset tokens on password change.
               # Delete the autologin tokens on password change to prohibit session leakage.
               # This helps to keep the account secure in case the associated email account
               # was compromised.
               def destroy_tokens
                 if hashed_password_changed?
                   tokens = ['recovery', 'autologin']
                   Token.where(:user_id => id, :action => tokens).delete_all
                 end
               end
               # 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.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.id])
                 Comment.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.id])
                 Issue.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.id])
                 Issue.where(['assigned_to_id = ?', id]).update_all('assigned_to_id = NULL')
                 Journal.where(['user_id = ?', id]).update_all(['user_id = ?', substitute.id])
                 JournalDetail.
                   where(["property = 'attr' AND prop_key = 'assigned_to_id' AND old_value = ?", id.to_s]).
                   update_all(['old_value = ?', substitute.id.to_s])
                 JournalDetail.
                   where(["property = 'attr' AND prop_key = 'assigned_to_id' AND value = ?", id.to_s]).
                   update_all(['value = ?', substitute.id.to_s])
                 Message.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.id])
                 News.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.id])
                 # Remove private queries and keep public ones
                 ::Query.delete_all ['user_id = ? AND visibility = ?', id, ::Query::VISIBILITY_PRIVATE]
                 ::Query.where(['user_id = ?', id]).update_all(['user_id = ?', substitute.id])
                 TimeEntry.where(['user_id = ?', id]).update_all(['user_id = ?', substitute.id])
                 Token.delete_all ['user_id = ?', id]
                 Watcher.delete_all ['user_id = ?', id]
                 WikiContent.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.id])
                 WikiContent::Version.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.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
                 Redmine::Utils.random_hex(16)
               end
             end
             class AnonymousUser < User
               validate :validate_anonymous_uniqueness, :on => :create
               def validate_anonymous_uniqueness
                 # There should be only one AnonymousUser in the database
                 errors.add :base, 'An anonymous user already exists.' if AnonymousUser.exists?
               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=(*args); nil end
               def mail; nil end
               def time_zone; nil end
               def rss_key; nil end
               def pref
                 UserPreference.new(:user => self)
               end
               # Returns the user's bult-in role
               def builtin_role
                 @builtin_role ||= Role.anonymous
               end
               def membership(*args)
                 nil
               end
               def member_of?(*args)
                 false
               end
               # Anonymous user can not be destroyed
               def destroy
                 false
               end
               protected
               def instantiate_email_address
               end
             end

app/views/my/password.html.erb +1 -1

             <h2><%=l(:button_change_password)%></h2>
             <%= error_messages_for 'user' %>
             <%= form_tag({}, :class => "tabular") do %>
             <div class="box">
             <p><label for="password"><%=l(:field_password)%> <span class="required">*</span></label>
             <%= password_field_tag 'password', nil, :size => 25 %></p>
             <p><label for="new_password"><%=l(:field_new_password)%> <span class="required">*</span></label>
             <%= password_field_tag 'new_password', nil, :size => 25 %>
             <em class="info"><%= l(:text_caracters_minimum, :count => Setting.password_min_length) %></em></p>
             <p><label for="new_password_confirmation"><%=l(:field_password_confirmation)%> <span class="required">*</span></label>
             <%= password_field_tag 'new_password_confirmation', nil, :size => 25 %></p>
             </div>
             <%= submit_tag l(:button_apply) %>
             <% end %>
-            <% unless @user.must_change_passwd? %>
+            <% unless @user.must_change_passwd? || @user.password_expired? %>
             <% content_for :sidebar do %>
             <%= render :partial => 'sidebar' %>
             <% end %>
             <% end %>

app/views/settings/_authentication.html.erb +4 0

             <%= form_tag({:action => 'edit', :tab => 'authentication'}) do %>
             <div class="box tabular settings">
             <p><%= setting_check_box :login_required %></p>
             <p><%= setting_select :autologin, [[l(:label_disabled), 0]] + [1, 7, 30, 365].collect{|days| [l('datetime.distance_in_words.x_days', :count => days), days.to_s]} %></p>
             <p><%= setting_select :self_registration, [[l(:label_disabled), "0"],
                                                        [l(:label_registration_activation_by_email), "1"],
                                                        [l(:label_registration_manual_activation), "2"],
                                                        [l(:label_registration_automatic_activation), "3"]] %></p>
             <p><%= setting_check_box :unsubscribe %></p>
             <p><%= setting_text_field :password_min_length, :size => 6 %></p>
+            <p>
+              <%= setting_select :password_max_age, [[l(:label_disabled), 0]] + [7, 30, 60, 90, 180, 365].collect{|days| [l('datetime.distance_in_words.x_days', :count => days), days.to_s]} %>
+            </p>
             <p><%= setting_check_box :lost_password, :label => :label_password_lost %></p>
             <p><%= setting_text_field :max_additional_emails, :size => 6 %></p>
             <p><%= setting_check_box :openid, :disabled => !Object.const_defined?(:OpenID) %></p>
             <p><%= setting_check_box :rest_api_enabled %></p>
             <p><%= setting_check_box :jsonp_enabled %></p>
             </div>
             <fieldset class="box">
               <legend><%= l(:label_session_expiration) %></legend>
               <div class="tabular settings">
                 <p><%= setting_select :session_lifetime, [[l(:label_disabled), 0]] + [1, 7, 30, 60, 365].collect{|days| [l('datetime.distance_in_words.x_days', :count => days), (days * 60 * 24).to_s]} %></p>
                 <p><%= setting_select :session_timeout, [[l(:label_disabled), 0]] + [1, 2, 4, 8, 12, 24, 48].collect{|hours| [l('datetime.distance_in_words.x_hours', :count => hours), (hours * 60).to_s]} %></p>
               </div>
               <p><em class="info"><%= l(:text_session_expiration_settings) %></em></p>
             </fieldset>
             <%= submit_tag l(:button_save) %>
             <% end %>

config/locales/de.yml +1 0

             # German translations for Ruby on Rails
             # by Clemens Kofler (clemens@railway.at)
             # additions for Redmine 1.2 by Jens Martsch (jmartsch@gmail.com)
             de:
               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: "%d.%m.%Y"
                   short: "%e. %b"
                   long: "%e. %B %Y"
                 day_names: [Sonntag, Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag]
                 abbr_day_names: [So, Mo, Di, Mi, Do, Fr, Sa]
                 # Don't forget the nil at the beginning; there's no such thing as a 0th month
                 month_names: [~, Januar, Februar, März, April, Mai, Juni, Juli, August, September, Oktober, November, Dezember]
                 abbr_month_names: [~, Jan, Feb, Mär, Apr, Mai, Jun, Jul, Aug, Sep, Okt, Nov, Dez]
                 # Used in date_select and datime_select.
                 order:
                   - :day
                   - :month
                   - :year
               time:
                 formats:
                   default: "%d.%m.%Y %H:%M"
                   time: "%H:%M"
                   short: "%e. %b %H:%M"
                   long: "%A, %e. %B %Y, %H:%M Uhr"
                 am: "vormittags"
                 pm: "nachmittags"
               datetime:
                 distance_in_words:
                   half_a_minute: 'eine halbe Minute'
                   less_than_x_seconds:
                     one: 'weniger als 1 Sekunde'
                     other: 'weniger als %{count} Sekunden'
                   x_seconds:
                     one: '1 Sekunde'
                     other: '%{count} Sekunden'
                   less_than_x_minutes:
                     one: 'weniger als 1 Minute'
                     other: 'weniger als %{count} Minuten'
                   x_minutes:
                     one: '1 Minute'
                     other: '%{count} Minuten'
                   about_x_hours:
                     one: 'etwa 1 Stunde'
                     other: 'etwa %{count} Stunden'
                   x_hours:
                     one:   "1 Stunde"
                     other: "%{count} Stunden"
                   x_days:
                     one: '1 Tag'
                     other: '%{count} Tagen'
                   about_x_months:
                     one: 'etwa 1 Monat'
                     other: 'etwa %{count} Monaten'
                   x_months:
                     one: '1 Monat'
                     other: '%{count} Monaten'
                   about_x_years:
                     one: 'etwa 1 Jahr'
                     other: 'etwa %{count} Jahren'
                   over_x_years:
                     one: 'mehr als 1 Jahr'
                     other: 'mehr als %{count} Jahren'
                   almost_x_years:
                     one:   "fast 1 Jahr"
                     other: "fast %{count} Jahren"
               number:
                 # Default format for numbers
                 format:
                   separator: ','
                   delimiter: '.'
                   precision: 2
                 currency:
                   format:
                     unit: '€'
                     format: '%n %u'
                     delimiter: ''
                 percentage:
                   format:
                     delimiter: ""
                 precision:
                   format:
                     delimiter: ""
                 human:
                   format:
                     delimiter: ""
                     precision: 3
                   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: "und"
                   skip_last_comma: true
               activerecord:
                 errors:
                   template:
                     header:
                       one:    "Dieses %{model}-Objekt konnte nicht gespeichert werden: %{count} Fehler."
                       other:  "Dieses %{model}-Objekt konnte nicht gespeichert werden: %{count} Fehler."
                     body: "Bitte überprüfen Sie die folgenden Felder:"
                   messages:
                     inclusion: "ist kein gültiger Wert"
                     exclusion: "ist nicht verfügbar"
                     invalid: "ist nicht gültig"
                     confirmation: "stimmt nicht mit der Bestätigung überein"
                     accepted: "muss akzeptiert werden"
                     empty: "muss ausgefüllt werden"
                     blank: "muss ausgefüllt werden"
                     too_long: "ist zu lang (nicht mehr als %{count} Zeichen)"
                     too_short: "ist zu kurz (nicht weniger als %{count} Zeichen)"
                     wrong_length: "hat die falsche Länge (muss genau %{count} Zeichen haben)"
                     taken: "ist bereits vergeben"
                     not_a_number: "ist keine Zahl"
                     not_a_date: "ist kein gültiges Datum"
                     greater_than: "muss größer als %{count} sein"
                     greater_than_or_equal_to: "muss größer oder gleich %{count} sein"
                     equal_to: "muss genau %{count} sein"
                     less_than: "muss kleiner als %{count} sein"
                     less_than_or_equal_to: "muss kleiner oder gleich %{count} sein"
                     odd: "muss ungerade sein"
                     even: "muss gerade sein"
                     greater_than_start_date: "muss größer als Anfangsdatum sein"
                     not_same_project: "gehört nicht zum selben Projekt"
                     circular_dependency: "Diese Beziehung würde eine zyklische Abhängigkeit erzeugen"
                     cant_link_an_issue_with_a_descendant: "Ein Ticket kann nicht mit einer Ihrer Unteraufgaben verlinkt werden"
                     earlier_than_minimum_start_date: "cannot be earlier than %{date} because of preceding issues"
               actionview_instancetag_blank_option: Bitte auswählen
               button_activate: Aktivieren
               button_add: Hinzufügen
               button_annotate: Annotieren
               button_apply: Anwenden
               button_archive: Archivieren
               button_back: Zurück
               button_cancel: Abbrechen
               button_change: Wechseln
               button_change_password: Kennwort ändern
               button_check_all: Alles auswählen
               button_clear: Zurücksetzen
               button_close: Schließen
               button_collapse_all: Alle einklappen
               button_configure: Konfigurieren
               button_copy: Kopieren
               button_copy_and_follow: Kopieren und Ticket anzeigen
               button_create: Anlegen
               button_create_and_continue: Anlegen und weiter
               button_delete: Löschen
               button_delete_my_account: Mein Benutzerkonto löschen
               button_download: Download
               button_duplicate: Duplizieren
               button_edit: Bearbeiten
               button_edit_associated_wikipage: "Zugehörige Wikiseite bearbeiten: %{page_title}"
               button_edit_section: Diesen Bereich bearbeiten
               button_expand_all: Alle ausklappen
               button_export: Exportieren
               button_hide: Verstecken
               button_list: Liste
               button_lock: Sperren
               button_log_time: Aufwand buchen
               button_login: Anmelden
               button_move: Verschieben
               button_move_and_follow: Verschieben und Ticket anzeigen
               button_quote: Zitieren
               button_rename: Umbenennen
               button_reopen: Öffnen
               button_reply: Antworten
               button_reset: Zurücksetzen
               button_rollback: Auf diese Version zurücksetzen
               button_save: Speichern
               button_show: Anzeigen
               button_sort: Sortieren
               button_submit: OK
               button_test: Testen
               button_unarchive: Entarchivieren
               button_uncheck_all: Alles abwählen
               button_unlock: Entsperren
               button_unwatch: Nicht beobachten
               button_update: Aktualisieren
               button_view: Anzeigen
               button_watch: Beobachten
               default_activity_design: Design
               default_activity_development: Entwicklung
               default_doc_category_tech: Technische Dokumentation
               default_doc_category_user: Benutzerdokumentation
               default_issue_status_closed: Erledigt
               default_issue_status_feedback: Feedback
               default_issue_status_in_progress: In Bearbeitung
               default_issue_status_new: Neu
               default_issue_status_rejected: Abgewiesen
               default_issue_status_resolved: Gelöst
               default_priority_high: Hoch
               default_priority_immediate: Sofort
               default_priority_low: Niedrig
               default_priority_normal: Normal
               default_priority_urgent: Dringend
               default_role_developer: Entwickler
               default_role_manager: Manager
               default_role_reporter: Reporter
               default_tracker_bug: Fehler
               default_tracker_feature: Feature
               default_tracker_support: Unterstützung
               description_all_columns: Alle Spalten
               description_available_columns: Verfügbare Spalten
               description_choose_project: Projekte
               description_date_from: Startdatum eintragen
               description_date_range_interval: Zeitraum durch Start- und Enddatum festlegen
               description_date_range_list: Zeitraum aus einer Liste wählen
               description_date_to: Enddatum eintragen
               description_filter: Filter
               description_issue_category_reassign: Neue Kategorie wählen
               description_message_content: Nachrichteninhalt
               description_notes: Kommentare
               description_project_scope: Suchbereich
               description_query_sort_criteria_attribute: Sortierattribut
               description_query_sort_criteria_direction: Sortierrichtung
               description_search: Suchfeld
               description_selected_columns: Ausgewählte Spalten
               description_user_mail_notification: Mailbenachrichtigungseinstellung
               description_wiki_subpages_reassign: Neue Elternseite wählen
               enumeration_activities: Aktivitäten (Zeiterfassung)
               enumeration_doc_categories: Dokumentenkategorien
               enumeration_issue_priorities: Ticket-Prioritäten
               enumeration_system_activity: System-Aktivität
               error_attachment_too_big: Diese Datei kann nicht hochgeladen werden, da sie die maximale Dateigröße von (%{max_size}) überschreitet.
               error_can_not_archive_project: Dieses Projekt kann nicht archiviert werden.
               error_can_not_delete_custom_field: Kann das benutzerdefinierte Feld nicht löschen.
               error_can_not_delete_tracker: Dieser Tracker enthält Tickets und kann nicht gelöscht werden.
               error_can_not_remove_role: Diese Rolle wird verwendet und kann nicht gelöscht werden.
               error_can_not_reopen_issue_on_closed_version: Das Ticket ist einer abgeschlossenen Version zugeordnet und kann daher nicht wieder geöffnet werden.
               error_can_t_load_default_data: "Die Standard-Konfiguration konnte nicht geladen werden: %{value}"
               error_issue_done_ratios_not_updated: Der Ticket-Fortschritt wurde nicht aktualisiert.
               error_issue_not_found_in_project: 'Das Ticket wurde nicht gefunden oder gehört nicht zu diesem Projekt.'
               error_no_default_issue_status: Es ist kein Status als Standard definiert. Bitte überprüfen Sie Ihre Konfiguration (unter "Administration -> Ticket-Status").
               error_no_tracker_in_project: Diesem Projekt ist kein Tracker zugeordnet. Bitte überprüfen Sie die Projekteinstellungen.
               error_scm_annotate: "Der Eintrag existiert nicht oder kann nicht annotiert werden."
               error_scm_annotate_big_text_file: Der Eintrag kann nicht umgesetzt werden, da er die maximale Textlänge überschreitet.
               error_scm_command_failed: "Beim Zugriff auf das Projektarchiv ist ein Fehler aufgetreten: %{value}"
               error_scm_not_found: Eintrag und/oder Revision existiert nicht im Projektarchiv.
               error_session_expired: Ihre Sitzung ist abgelaufen. Bitte melden Sie sich erneut an.
               error_unable_delete_issue_status: "Der Ticket-Status konnte nicht gelöscht werden."
               error_unable_to_connect: Fehler beim Verbinden (%{value})
               error_workflow_copy_source: Bitte wählen Sie einen Quell-Tracker und eine Quell-Rolle.
               error_workflow_copy_target: Bitte wählen Sie die Ziel-Tracker und -Rollen.
               field_account: Konto
               field_active: Aktiv
               field_activity: Aktivität
               field_admin: Administrator
               field_assignable: Tickets können dieser Rolle zugewiesen werden
               field_assigned_to: Zugewiesen an
               field_assigned_to_role: Zuständigkeitsrolle
               field_attr_firstname: Vorname-Attribut
               field_attr_lastname: Name-Attribut
               field_attr_login: Mitgliedsname-Attribut
               field_attr_mail: E-Mail-Attribut
               field_auth_source: Authentifizierungs-Modus
               field_auth_source_ldap_filter: LDAP-Filter
               field_author: Autor
               field_base_dn: Base DN
               field_board_parent: Übergeordnetes Forum
               field_category: Kategorie
               field_column_names: Spalten
               field_closed_on: Geschlossen am
               field_comments: Kommentar
               field_comments_sorting: Kommentare anzeigen
               field_commit_logs_encoding: Kodierung der Commit-Log-Meldungen
               field_content: Inhalt
               field_core_fields: Standardwerte
               field_created_on: Angelegt
               field_cvs_module: Modul
               field_cvsroot: CVSROOT
               field_default_value: Standardwert
               field_default_status: Standardstatus
               field_delay: Pufferzeit
               field_description: Beschreibung
               field_done_ratio: "% erledigt"
               field_downloads: Downloads
               field_due_date: Abgabedatum
               field_editable: Bearbeitbar
               field_effective_date: Datum
               field_estimated_hours: Geschätzter Aufwand
               field_field_format: Format
               field_filename: Datei
               field_filesize: Größe
               field_firstname: Vorname
               field_fixed_version: Zielversion
               field_generate_password: Passwort generieren
               field_group_by: Gruppiere Ergebnisse nach
               field_hide_mail: E-Mail-Adresse nicht anzeigen
               field_homepage: Projekt-Homepage
               field_host: Host
               field_hours: Stunden
               field_identifier: Kennung
               field_identity_url: OpenID-URL
               field_inherit_members: Benutzer erben
               field_is_closed: Ticket geschlossen
               field_is_default: Standardeinstellung
               field_is_filter: Als Filter benutzen
               field_is_for_all: Für alle Projekte
               field_is_in_roadmap: In der Roadmap anzeigen
               field_is_private: Privat
               field_is_public: Öffentlich
               field_is_required: Erforderlich
               field_issue: Ticket
               field_issue_to: Zugehöriges Ticket
               field_issues_visibility: Ticket Sichtbarkeit
               field_language: Sprache
               field_last_login_on: Letzte Anmeldung
               field_lastname: Nachname
               field_login: Mitgliedsname
               field_mail: E-Mail
               field_mail_notification: Mailbenachrichtigung
               field_max_length: Maximale Länge
               field_member_of_group: Zuständigkeitsgruppe
               field_min_length: Minimale Länge
               field_multiple: Mehrere Werte
               field_must_change_passwd: Passwort beim nächsten Login ändern
               field_name: Name
               field_new_password: Neues Kennwort
               field_notes: Kommentare
               field_onthefly: On-the-fly-Benutzererstellung
               field_parent: Unterprojekt von
               field_parent_issue: Übergeordnete Aufgabe
               field_parent_title: Übergeordnete Seite
               field_password: Kennwort
               field_password_confirmation: Bestätigung
               field_path_to_repository: Pfad zum Repository
               field_port: Port
               field_possible_values: Mögliche Werte
               field_principal: Auftraggeber
               field_priority: Priorität
               field_private_notes: Privater Kommentar
               field_project: Projekt
               field_redirect_existing_links: Existierende Links umleiten
               field_regexp: Regulärer Ausdruck
               field_repository_is_default: Haupt-Repository
               field_role: Rolle
               field_root_directory: Wurzelverzeichnis
               field_scm_path_encoding: Pfad-Kodierung
               field_searchable: Durchsuchbar
               field_sharing: Gemeinsame Verwendung
               field_spent_on: Datum
               field_start_date: Beginn
               field_start_page: Hauptseite
               field_status: Status
               field_subject: Thema
               field_subproject: Unterprojekt von
               field_summary: Zusammenfassung
               field_text: Textfeld
               field_time_entries: Logzeit
               field_time_zone: Zeitzone
               field_timeout: Auszeit (in Sekunden)
               field_title: Titel
               field_tracker: Tracker
               field_type: Typ
               field_updated_on: Aktualisiert
               field_url: URL
               field_user: Benutzer
               field_users_visibility: Benutzer Sichtbarkeit
               field_value: Wert
               field_version: Version
               field_visible: Sichtbar
               field_warn_on_leaving_unsaved: Vor dem Verlassen einer Seite mit ungesichertem Text im Editor warnen
               field_watcher: Beobachter
               general_csv_decimal_separator: ','
               general_csv_encoding: ISO-8859-1
               general_csv_separator: ';'
               general_pdf_fontname: freesans
               general_first_day_of_week: '1'
               general_lang_name: 'German (Deutsch)'
               general_text_No: 'Nein'
               general_text_Yes: 'Ja'
               general_text_no: 'nein'
               general_text_yes: 'ja'
               label_activity: Aktivität
               label_add_another_file: Eine weitere Datei hinzufügen
               label_add_note: Kommentar hinzufügen
               label_add_projects: Projekt hinzufügen
               label_added: hinzugefügt
               label_added_time_by: "Von %{author} vor %{age} hinzugefügt"
               label_additional_workflow_transitions_for_assignee: Zusätzliche Berechtigungen wenn der Benutzer der Zugewiesene ist
               label_additional_workflow_transitions_for_author: Zusätzliche Berechtigungen wenn der Benutzer der Autor ist
               label_administration: Administration
               label_age: Geändert vor
               label_ago: vor
               label_all: alle
               label_all_time: gesamter Zeitraum
               label_all_words: Alle Wörter
               label_and_its_subprojects: "%{value} und dessen Unterprojekte"
               label_any: alle
               label_any_issues_in_project: irgendein Ticket im Projekt
               label_any_issues_not_in_project: irgendein Ticket nicht im Projekt
               label_api_access_key: API-Zugriffsschlüssel
               label_api_access_key_created_on: Der API-Zugriffsschlüssel wurde vor %{value} erstellt
               label_applied_status: Zugewiesener Status
               label_ascending: Aufsteigend
               label_ask: Nachfragen
               label_assigned_to_me_issues: Mir zugewiesene Tickets
               label_associated_revisions: Zugehörige Revisionen
               label_attachment: Datei
               label_attachment_delete: Anhang löschen
               label_attachment_new: Neue Datei
               label_attachment_plural: Dateien
               label_attribute: Attribut
               label_attribute_of_assigned_to: "%{name} des Bearbeiters"
               label_attribute_of_author: "%{name} des Autors"
               label_attribute_of_fixed_version: "%{name} der Zielversion"
               label_attribute_of_issue: "%{name} des Tickets"
               label_attribute_of_project: "%{name} des Projekts"
               label_attribute_of_user: "%{name} des Benutzers"
               label_attribute_plural: Attribute
               label_auth_source: Authentifizierungs-Modus
               label_auth_source_new: Neuer Authentifizierungs-Modus
               label_auth_source_plural: Authentifizierungs-Arten
               label_authentication: Authentifizierung
               label_between: zwischen
               label_blocked_by: Blockiert durch
               label_blocks: Blockiert
               label_board: Forum
               label_board_locked: Gesperrt
               label_board_new: Neues Forum
               label_board_plural: Foren
               label_board_sticky: Wichtig (immer oben)
               label_boolean: Boolean
               label_branch: Zweig
               label_browse: Codebrowser
               label_bulk_edit_selected_issues: Alle ausgewählten Tickets bearbeiten
               label_bulk_edit_selected_time_entries: Ausgewählte Zeitaufwände bearbeiten
               label_calendar: Kalender
               label_change_plural: Änderungen
               label_change_properties: Eigenschaften ändern
               label_change_status: Statuswechsel
               label_change_view_all: Alle Änderungen anzeigen
               label_changes_details: Details aller Änderungen
               label_changeset_plural: Changesets
               label_checkboxes: Checkboxen
               label_check_for_updates: Auf Updates prüfen
               label_child_revision: Nachfolger
               label_chronological_order: in zeitlicher Reihenfolge
               label_close_versions: Vollständige Versionen schließen
               label_closed_issues: geschlossen
               label_closed_issues_plural: geschlossen
               label_comment: Kommentar
               label_comment_add: Kommentar hinzufügen
               label_comment_added: Kommentar hinzugefügt
               label_comment_delete: Kommentar löschen
               label_comment_plural: Kommentare
               label_commits_per_author: Übertragungen pro Autor
               label_commits_per_month: Übertragungen pro Monat
               label_completed_versions: Abgeschlossene Versionen
               label_confirmation: Bestätigung
               label_contains: enthält
               label_copied: kopiert
               label_copied_from: Kopiert von
               label_copied_to: Kopiert nach
               label_copy_attachments: Anhänge kopieren
               label_copy_same_as_target: So wie das Ziel
               label_copy_source: Quelle
               label_copy_subtasks: Unteraufgaben kopieren
               label_copy_target: Ziel
               label_copy_workflow_from: Workflow kopieren von
               label_cross_project_descendants: Mit Unterprojekten
               label_cross_project_hierarchy: Mit Projekthierarchie
               label_cross_project_system: Mit allen Projekten
               label_cross_project_tree: Mit Projektbaum
               label_current_status: Gegenwärtiger Status
               label_current_version: Gegenwärtige Version
               label_custom_field: Benutzerdefiniertes Feld
               label_custom_field_new: Neues Feld
               label_custom_field_plural: Benutzerdefinierte Felder
               label_custom_field_select_type: Bitte wählen Sie den Objekttyp, zu dem das benutzerdefinierte Feld hinzugefügt werden soll
               label_date: Datum
               label_date_from: Von
               label_date_from_to: von %{start} bis %{end}
               label_date_range: Zeitraum
               label_date_to: Bis
               label_day_plural: Tage
               label_default: Standard
               label_default_columns: Standard-Spalten
               label_deleted: gelöscht
               label_descending: Absteigend
               label_details: Details
               label_diff: diff
               label_diff_inline: einspaltig
               label_diff_side_by_side: nebeneinander
               label_disabled: gesperrt
               label_display: Anzeige
               label_display_per_page: "Pro Seite: %{value}"
               label_display_used_statuses_only: Zeige nur Status an, die von diesem Tracker verwendet werden
               label_document: Dokument
               label_document_added: Dokument hinzugefügt
               label_document_new: Neues Dokument
               label_document_plural: Dokumente
               label_downloads_abbr: D/L
               label_drop_down_list: Dropdown-Liste
               label_duplicated_by: Dupliziert durch
               label_duplicates: Duplikat von
               label_edit_attachments: Angehängte Dateien bearbeiten
               label_end_to_end: Ende - Ende
               label_end_to_start: Ende - Anfang
               label_enumeration_new: Neuer Wert
               label_enumerations: Aufzählungen
               label_environment: Umgebung
               label_equals: ist
               label_example: Beispiel
               label_export_options: "%{export_format} Export-Eigenschaften"
               label_export_to: "Auch abrufbar als:"
               label_f_hour: "%{value} Stunde"
               label_f_hour_plural: "%{value} Stunden"
               label_feed_plural: Feeds
               label_feeds_access_key: Atom-Zugriffsschlüssel
               label_feeds_access_key_created_on: "Atom-Zugriffsschlüssel vor %{value} erstellt"
               label_fields_permissions: Feldberechtigungen
               label_file_added: Datei hinzugefügt
               label_file_plural: Dateien
               label_filter_add: Filter hinzufügen
               label_filter_plural: Filter
               label_float: Fließkommazahl
               label_follows: Nachfolger von
               label_gantt: Gantt-Diagramm
               label_gantt_progress_line: Fortschrittslinie
               label_general: Allgemein
               label_generate_key: Generieren
               label_git_report_last_commit: Bericht des letzten Commits für Dateien und Verzeichnisse
               label_greater_or_equal: ">="
               label_group: Gruppe
               label_group_anonymous: Anonyme Benutzer
               label_group_new: Neue Gruppe
               label_group_non_member: Nichtmitglieder
               label_group_plural: Gruppen
               label_help: Hilfe
               label_hidden: Versteckt
               label_history: Historie
               label_home: Hauptseite
               label_in: in
               label_in_less_than: in weniger als
               label_in_more_than: in mehr als
               label_in_the_next_days: in den nächsten
               label_in_the_past_days: in den letzten
               label_incoming_emails: Eingehende E-Mails
               label_index_by_date: Seiten nach Datum sortiert
               label_index_by_title: Seiten nach Titel sortiert
               label_information: Information
               label_information_plural: Informationen
               label_integer: Zahl
               label_internal: Intern
               label_issue: Ticket
               label_issue_added: Ticket hinzugefügt
               label_issue_assigned_to_updated: Bearbeiter aktualisiert
               label_issue_category: Ticket-Kategorie
               label_issue_category_new: Neue Kategorie
               label_issue_category_plural: Ticket-Kategorien
               label_issue_new: Neues Ticket
               label_issue_note_added: Notiz hinzugefügt
               label_issue_plural: Tickets
               label_issue_priority_updated: Priorität aktualisiert
               label_issue_status: Ticket-Status
               label_issue_status_new: Neuer Status
               label_issue_status_plural: Ticket-Status
               label_issue_status_updated: Status aktualisiert
               label_issue_tracking: Tickets
               label_issue_updated: Ticket aktualisiert
               label_issue_view_all: Alle Tickets anzeigen
               label_issue_watchers: Beobachter
               label_issues_by: "Tickets pro %{value}"
               label_issues_visibility_all: Alle Tickets
               label_issues_visibility_own: Tickets die folgender Benutzer erstellt hat oder die ihm zugewiesen sind
               label_issues_visibility_public: Alle öffentlichen Tickets
               label_item_position: "%{position}/%{count}"
               label_jump_to_a_project: Zu einem Projekt springen...
               label_language_based: Sprachabhängig
               label_last_changes: "%{count} letzte Änderungen"
               label_last_login: Letzte Anmeldung
               label_last_month: voriger Monat
               label_last_n_days: "die letzten %{count} Tage"
               label_last_n_weeks: letzte %{count} Wochen
               label_last_week: vorige Woche
               label_latest_compatible_version: Letzte kompatible Version
               label_latest_revision: Aktuellste Revision
               label_latest_revision_plural: Aktuellste Revisionen
               label_ldap_authentication: LDAP-Authentifizierung
               label_less_or_equal: "<="
               label_less_than_ago: vor weniger als
               label_link: Link
               label_link_copied_issue: Kopierte Tickets verlinken
               label_link_values_to: Werte mit URL verknüpfen
               label_list: Liste
               label_loading: Lade...
               label_logged_as: Angemeldet als
               label_login: Anmelden
               label_login_with_open_id_option: oder mit OpenID anmelden
               label_logout: Abmelden
               label_only: nur
               label_max_size: Maximale Größe
               label_me: ich
               label_member: Mitglied
               label_member_new: Neues Mitglied
               label_member_plural: Mitglieder
               label_message_last: Letzter Forenbeitrag
               label_message_new: Neues Thema
               label_message_plural: Forenbeiträge
               label_message_posted: Forenbeitrag hinzugefügt
               label_min_max_length: Länge (Min. - Max.)
               label_missing_api_access_key: Der API-Zugriffsschlüssel fehlt.
               label_missing_feeds_access_key: Der Atom-Zugriffsschlüssel fehlt.
               label_modified: geändert
               label_module_plural: Module
               label_month: Monat
               label_months_from: Monate ab
               label_more: Mehr
               label_more_than_ago: vor mehr als
               label_my_account: Mein Konto
               label_my_page: Meine Seite
               label_my_page_block: Verfügbare Widgets
               label_my_projects: Meine Projekte
               label_my_queries: Meine eigenen Abfragen
               label_new: Neu
               label_new_statuses_allowed: Neue Berechtigungen
               label_news: News
               label_news_added: News hinzugefügt
               label_news_comment_added: Kommentar zu einer News hinzugefügt
               label_news_latest: Letzte News
               label_news_new: News hinzufügen
               label_news_plural: News
               label_news_view_all: Alle News anzeigen
               label_next: Weiter
               label_no_change_option: (Keine Änderung)
               label_no_data: Nichts anzuzeigen
               label_no_issues_in_project: keine Tickets im Projekt
               label_nobody: Niemand
               label_none: kein
               label_not_contains: enthält nicht
               label_not_equals: ist nicht
               label_open_issues: offen
               label_open_issues_plural: offen
               label_optional_description: Beschreibung (optional)
               label_options: Optionen
               label_overall_activity: Aktivitäten aller Projekte anzeigen
               label_overall_spent_time: Aufgewendete Zeit aller Projekte anzeigen
               label_overview: Übersicht
               label_parent_revision: Vorgänger
               label_password_lost: Kennwort vergessen
               label_permissions: Berechtigungen
               label_permissions_report: Berechtigungsübersicht
               label_personalize_page: Diese Seite anpassen
               label_planning: Terminplanung
               label_please_login: Anmelden
               label_plugins: Plugins
               label_precedes: Vorgänger von
               label_preferences: Präferenzen
               label_preview: Vorschau
               label_previous: Zurück
               label_principal_search: "Nach Benutzer oder Gruppe suchen:"
               label_profile: Profil
               label_project: Projekt
               label_project_all: Alle Projekte
               label_project_copy_notifications: Sende Mailbenachrichtigungen beim Kopieren des Projekts.
               label_project_latest: Neueste Projekte
               label_project_new: Neues Projekt
               label_project_plural: Projekte
               label_public_projects: Öffentliche Projekte
               label_query: Benutzerdefinierte Abfrage
               label_query_new: Neue Abfrage
               label_query_plural: Benutzerdefinierte Abfragen
               label_radio_buttons: Radio-Buttons
               label_read: Lesen...
               label_readonly: Nur-Lese-Zugriff
               label_register: Registrieren
               label_registered_on: Angemeldet am
               label_registration_activation_by_email: Kontoaktivierung durch E-Mail
               label_registration_automatic_activation: Automatische Kontoaktivierung
               label_registration_manual_activation: Manuelle Kontoaktivierung
               label_related_issues: Zugehörige Tickets
               label_relates_to: Beziehung mit
               label_relation_delete: Beziehung löschen
               label_relation_new: Neue Beziehung
               label_renamed: umbenannt
               label_reply_plural: Antworten
               label_report: Bericht
               label_report_plural: Berichte
               label_reported_issues: Erstellte Tickets
               label_repository: Projektarchiv
               label_repository_new: Neues Repository
               label_repository_plural: Projektarchive
               label_required: Erforderlich
               label_result_plural: Resultate
               label_reverse_chronological_order: in umgekehrter zeitlicher Reihenfolge
               label_revision: Revision
               label_revision_id: Revision %{value}
               label_revision_plural: Revisionen
               label_roadmap: Roadmap
               label_roadmap_due_in: "Fällig in %{value}"
               label_roadmap_no_issues: Keine Tickets für diese Version
               label_roadmap_overdue: "seit %{value} verspätet"
               label_role: Rolle
               label_role_and_permissions: Rollen und Rechte
               label_role_anonymous: Anonymous
               label_role_new: Neue Rolle
               label_role_non_member: Nichtmitglied
               label_role_plural: Rollen
               label_scm: Versionskontrollsystem
               label_search: Suche
               label_search_for_watchers: Nach hinzufügbaren Beobachtern suchen
               label_search_titles_only: Nur Titel durchsuchen
               label_send_information: Sende Kontoinformationen an Benutzer
               label_send_test_email: Test-E-Mail senden
               label_session_expiration: Ende einer Sitzung
               label_settings: Konfiguration
               label_show_closed_projects: Geschlossene Projekte anzeigen
               label_show_completed_versions: Abgeschlossene Versionen anzeigen
               label_sort: Sortierung
               label_sort_by: "Sortiert nach %{value}"
               label_sort_higher: Eins höher
               label_sort_highest: An den Anfang
               label_sort_lower: Eins tiefer
               label_sort_lowest: Ans Ende
               label_spent_time: Aufgewendete Zeit
               label_start_to_end: Anfang - Ende
               label_start_to_start: Anfang - Anfang
               label_statistics: Statistiken
               label_status_transitions: Statusänderungen
               label_stay_logged_in: Angemeldet bleiben
               label_string: Text
               label_subproject_new: Neues Unterprojekt
               label_subproject_plural: Unterprojekte
               label_subtask_plural: Unteraufgaben
               label_tag: Markierung
               label_text: Langer Text
               label_theme: Stil
               label_this_month: aktueller Monat
               label_this_week: aktuelle Woche
               label_this_year: aktuelles Jahr
               label_time_entry_plural: Benötigte Zeit
               label_time_tracking: Zeiterfassung
               label_today: heute
               label_topic_plural: Themen
               label_total: Gesamtzahl
               label_total_time: Gesamtzeit
               label_tracker: Tracker
               label_tracker_new: Neuer Tracker
               label_tracker_plural: Tracker
               label_unknown_plugin: Unbekanntes Plugin
               label_update_issue_done_ratios: Ticket-Fortschritt aktualisieren
               label_updated_time: "Vor %{value} aktualisiert"
               label_updated_time_by: "Von %{author} vor %{age} aktualisiert"
               label_used_by: Benutzt von
               label_user: Benutzer
               label_user_activity: "Aktivität von %{value}"
               label_user_anonymous: Anonym
               label_user_mail_no_self_notified: "Ich möchte nicht über Änderungen benachrichtigt werden, die ich selbst durchführe."
               label_user_mail_option_all: "Für alle Ereignisse in all meinen Projekten"
               label_user_mail_option_none: Keine Ereignisse
               label_user_mail_option_only_assigned: Nur für Aufgaben für die ich zuständig bin
               label_user_mail_option_only_my_events: Nur für Aufgaben die ich beobachte oder an welchen ich mitarbeite
               label_user_mail_option_only_owner: Nur für Aufgaben die ich angelegt habe
               label_user_mail_option_selected: "Für alle Ereignisse in den ausgewählten Projekten"
               label_user_new: Neuer Benutzer
               label_user_plural: Benutzer
               label_user_search: "Nach Benutzer suchen:"
               label_users_visibility_all: Alle aktiven Benutzer
               label_users_visibility_members_of_visible_projects: Mitglieder von sichtbaren Projekten
               label_version: Version
               label_version_new: Neue Version
               label_version_plural: Versionen
               label_version_sharing_descendants: Mit Unterprojekten
               label_version_sharing_hierarchy: Mit Projekthierarchie
               label_version_sharing_none: Nicht gemeinsam verwenden
               label_version_sharing_system: Mit allen Projekten
               label_version_sharing_tree: Mit Projektbaum
               label_view_all_revisions: Alle Revisionen anzeigen
               label_view_diff: Unterschiede anzeigen
               label_view_revisions: Revisionen anzeigen
               label_visibility_private: nur für mich
               label_visibility_public: für jeden Benutzer
               label_visibility_roles: nur für diese Rollen
               label_watched_issues: Beobachtete Tickets
               label_week: Woche
               label_wiki: Wiki
               label_wiki_content_added: Wiki-Seite hinzugefügt
               label_wiki_content_updated: Wiki-Seite aktualisiert
               label_wiki_edit: Wiki-Bearbeitung
               label_wiki_edit_plural: Wiki-Bearbeitungen
               label_wiki_page: Wiki-Seite
               label_wiki_page_plural: Wiki-Seiten
               label_workflow: Workflow
               label_x_closed_issues_abbr:
                 zero:  0 geschlossen
                 one:   1 geschlossen
                 other: "%{count} geschlossen"
               label_x_comments:
                 zero: keine Kommentare
                 one: 1 Kommentar
                 other: "%{count} Kommentare"
               label_x_issues:
                 zero:  0 Tickets
                 one:   1 Ticket
                 other: "%{count} Tickets"
               label_x_open_issues_abbr:
                 zero:  0 offen
                 one:   1 offen
                 other: "%{count} offen"
               label_x_open_issues_abbr_on_total:
                 zero:  0 offen / %{total}
                 one:   1 offen / %{total}
                 other: "%{count} offen / %{total}"
               label_x_projects:
                 zero:  keine Projekte
                 one:   1 Projekt
                 other: "%{count} Projekte"
               label_year: Jahr
               label_yesterday: gestern
               mail_body_account_activation_request: "Ein neuer Benutzer (%{value}) hat sich registriert. Sein Konto wartet auf Ihre Genehmigung:"
               mail_body_account_information: Ihre Konto-Informationen
               mail_body_account_information_external: "Sie können sich mit Ihrem Konto %{value} anmelden."
               mail_body_lost_password: 'Benutzen Sie den folgenden Link, um Ihr Kennwort zu ändern:'
               mail_body_register: 'Um Ihr Konto zu aktivieren, benutzen Sie folgenden Link:'
               mail_body_reminder: "%{count} Tickets, die Ihnen zugewiesen sind, müssen in den nächsten %{days} Tagen abgegeben werden:"
               mail_body_wiki_content_added: "Die Wiki-Seite '%{id}' wurde von %{author} hinzugefügt."
               mail_body_wiki_content_updated: "Die Wiki-Seite '%{id}' wurde von %{author} aktualisiert."
               mail_subject_account_activation_request: "Antrag auf %{value} Kontoaktivierung"
               mail_subject_lost_password: "Ihr %{value} Kennwort"
               mail_subject_register: "%{value} Kontoaktivierung"
               mail_subject_reminder: "%{count} Tickets müssen in den nächsten %{days} Tagen abgegeben werden"
               mail_subject_wiki_content_added: "Wiki-Seite '%{id}' hinzugefügt"
               mail_subject_wiki_content_updated: "Wiki-Seite '%{id}' erfolgreich aktualisiert"
               notice_account_activated: Ihr Konto ist aktiviert. Sie können sich jetzt anmelden.
               notice_account_deleted: Ihr Benutzerkonto wurde unwiderruflich gelöscht.
               notice_account_invalid_creditentials: Benutzer oder Kennwort ist ungültig.
               notice_account_lost_email_sent: Eine E-Mail mit Anweisungen, ein neues Kennwort zu wählen, wurde Ihnen geschickt.
               notice_account_locked: Ihr Konto ist gesperrt.
               notice_account_not_activated_yet: Sie haben Ihr Konto noch nicht aktiviert. Wenn Sie die Aktivierungsmail erneut erhalten wollen, <a href="%{url}">klicken Sie bitte hier</a>.
               notice_account_password_updated: Kennwort wurde erfolgreich aktualisiert.
               notice_account_pending: "Ihr Konto wurde erstellt und wartet jetzt auf die Genehmigung des Administrators."
               notice_account_register_done: Konto wurde erfolgreich angelegt. Eine E-Mail mit weiteren Instruktionen zur Kontoaktivierung wurde an %{email} gesendet.
               notice_account_unknown_email: Unbekannter Benutzer.
               notice_account_updated: Konto wurde erfolgreich aktualisiert.
               notice_account_wrong_password: Falsches Kennwort.
               notice_api_access_key_reseted: Ihr API-Zugriffsschlüssel wurde zurückgesetzt.
               notice_can_t_change_password: Dieses Konto verwendet eine externe Authentifizierungs-Quelle. Unmöglich, das Kennwort zu ändern.
               notice_default_data_loaded: Die Standard-Konfiguration wurde erfolgreich geladen.
               notice_email_error: "Beim Senden einer E-Mail ist ein Fehler aufgetreten (%{value})."
               notice_email_sent: "Eine E-Mail wurde an %{value} gesendet."
               notice_failed_to_save_issues: "%{count} von %{total} ausgewählten Tickets konnte(n) nicht gespeichert werden: %{ids}."
               notice_failed_to_save_members: "Benutzer konnte nicht gespeichert werden: %{errors}."
               notice_failed_to_save_time_entries: "Gescheitert %{count} Zeiteinträge für %{total} von ausgewählten: %{ids} zu speichern."
               notice_feeds_access_key_reseted: Ihr Atom-Zugriffsschlüssel wurde zurückgesetzt.
               notice_file_not_found: Anhang existiert nicht oder ist gelöscht worden.
               notice_gantt_chart_truncated: Die Grafik ist unvollständig, da das Maximum der anzeigbaren Aufgaben überschritten wurde (%{max})
               notice_issue_done_ratios_updated: Der Ticket-Fortschritt wurde aktualisiert.
               notice_issue_successful_create: Ticket %{id} erstellt.
               notice_issue_update_conflict: Das Ticket wurde während Ihrer Bearbeitung von einem anderen Nutzer überarbeitet.
               notice_locking_conflict: Datum wurde von einem anderen Benutzer geändert.
               notice_new_password_must_be_different: Das neue Passwort muss sich vom dem aktuellen
                 unterscheiden
               notice_no_issue_selected: "Kein Ticket ausgewählt! Bitte wählen Sie die Tickets, die Sie bearbeiten möchten."
               notice_not_authorized: Sie sind nicht berechtigt, auf diese Seite zuzugreifen.
               notice_not_authorized_archived_project: Das Projekt wurde archiviert und ist daher nicht nicht verfügbar.
               notice_successful_connection: Verbindung erfolgreich.
               notice_successful_create: Erfolgreich angelegt
               notice_successful_delete: Erfolgreich gelöscht.
               notice_successful_update: Erfolgreich aktualisiert.
               notice_unable_delete_time_entry: Der Zeiterfassungseintrag konnte nicht gelöscht werden.
               notice_unable_delete_version: Die Version konnte nicht gelöscht werden.
               notice_user_successful_create: Benutzer %{id} angelegt.
               permission_add_issue_notes: Kommentare hinzufügen
               permission_add_issue_watchers: Beobachter hinzufügen
               permission_add_issues: Tickets hinzufügen
               permission_add_messages: Forenbeiträge hinzufügen
               permission_add_project: Projekt erstellen
               permission_add_subprojects: Unterprojekte erstellen
               permission_add_documents: Dokumente hinzufügen
               permission_browse_repository: Projektarchiv ansehen
               permission_close_project: Schließen / erneutes Öffnen eines Projekts
               permission_comment_news: News kommentieren
               permission_commit_access: Commit-Zugriff
               permission_delete_issue_watchers: Beobachter löschen
               permission_delete_issues: Tickets löschen
               permission_delete_messages: Forenbeiträge löschen
               permission_delete_own_messages: Eigene Forenbeiträge löschen
               permission_delete_wiki_pages: Wiki-Seiten löschen
               permission_delete_wiki_pages_attachments: Anhänge löschen
               permission_delete_documents: Dokumente löschen
               permission_edit_issue_notes: Kommentare bearbeiten
               permission_edit_issues: Tickets bearbeiten
               permission_edit_messages: Forenbeiträge bearbeiten
               permission_edit_own_issue_notes: Eigene Kommentare bearbeiten
               permission_edit_own_messages: Eigene Forenbeiträge bearbeiten
               permission_edit_own_time_entries: Selbst gebuchte Aufwände bearbeiten
               permission_edit_project: Projekt bearbeiten
               permission_edit_time_entries: Gebuchte Aufwände bearbeiten
               permission_edit_wiki_pages: Wiki-Seiten bearbeiten
               permission_edit_documents: Dokumente bearbeiten
               permission_export_wiki_pages: Wiki-Seiten exportieren
               permission_log_time: Aufwände buchen
               permission_manage_boards: Foren verwalten
               permission_manage_categories: Ticket-Kategorien verwalten
               permission_manage_files: Dateien verwalten
               permission_manage_issue_relations: Ticket-Beziehungen verwalten
               permission_manage_members: Mitglieder verwalten
               permission_manage_news: News verwalten
               permission_manage_project_activities: Aktivitäten (Zeiterfassung) verwalten
               permission_manage_public_queries: Öffentliche Filter verwalten
               permission_manage_related_issues: Zugehörige Tickets verwalten
               permission_manage_repository: Projektarchiv verwalten
               permission_manage_subtasks: Unteraufgaben verwalten
               permission_manage_versions: Versionen verwalten
               permission_manage_wiki: Wiki verwalten
               permission_move_issues: Tickets verschieben
               permission_protect_wiki_pages: Wiki-Seiten schützen
               permission_rename_wiki_pages: Wiki-Seiten umbenennen
               permission_save_queries: Filter speichern
               permission_select_project_modules: Projektmodule auswählen
               permission_set_issues_private: Tickets privat oder öffentlich markieren
               permission_set_notes_private: Kommentar als privat markieren
               permission_set_own_issues_private: Eigene Tickets privat oder öffentlich markieren
               permission_view_calendar: Kalender ansehen
               permission_view_changesets: Changesets ansehen
               permission_view_documents: Dokumente ansehen
               permission_view_files: Dateien ansehen
               permission_view_gantt: Gantt-Diagramm ansehen
               permission_view_issue_watchers: Liste der Beobachter ansehen
               permission_view_issues: Tickets anzeigen
               permission_view_messages: Forenbeiträge ansehen
               permission_view_private_notes: Private Kommentare sehen
               permission_view_time_entries: Gebuchte Aufwände ansehen
               permission_view_wiki_edits: Wiki-Versionsgeschichte ansehen
               permission_view_wiki_pages: Wiki ansehen
               project_module_boards: Foren
               project_module_calendar: Kalender
               project_module_documents: Dokumente
               project_module_files: Dateien
               project_module_gantt: Gantt
               project_module_issue_tracking: Ticket-Verfolgung
               project_module_news: News
               project_module_repository: Projektarchiv
               project_module_time_tracking: Zeiterfassung
               project_module_wiki: Wiki
               project_status_active: aktiv
               project_status_archived: archiviert
               project_status_closed: geschlossen
               setting_activity_days_default: Anzahl Tage pro Seite der Projekt-Aktivität
               setting_app_subtitle: Applikations-Untertitel
               setting_app_title: Applikations-Titel
               setting_attachment_max_size: Max. Dateigröße
               setting_autofetch_changesets: Changesets automatisch abrufen
               setting_autologin: Automatische Anmeldung läuft ab nach
               setting_bcc_recipients: E-Mails als Blindkopie (BCC) senden
               setting_cache_formatted_text: Formatierten Text im Cache speichern
               setting_commit_cross_project_ref: Erlauben auf Tickets aller anderen Projekte zu referenzieren
               setting_commit_fix_keywords: Schlüsselwörter (Status)
               setting_commit_logtime_activity_id: Aktivität für die Zeiterfassung
               setting_commit_logtime_enabled: Aktiviere Zeitlogging
               setting_commit_ref_keywords: Schlüsselwörter (Beziehungen)
               setting_cross_project_issue_relations: Ticket-Beziehungen zwischen Projekten erlauben
               setting_cross_project_subtasks: Projektübergreifende Unteraufgaben erlauben
               setting_date_format: Datumsformat
               setting_default_issue_start_date_to_creation_date: Aktuelles Datum als Beginn für neue Tickets verwenden
               setting_default_language: Standardsprache
               setting_default_notification_option: Standard Benachrichtigungsoptionen
               setting_default_projects_modules: Standardmäßig aktivierte Module für neue Projekte
               setting_default_projects_public: Neue Projekte sind standardmäßig öffentlich
               setting_default_projects_tracker_ids: Standardmäßig aktivierte Tracker für neue Projekte
               setting_diff_max_lines_displayed: Maximale Anzahl anzuzeigender Diff-Zeilen
               setting_display_subprojects_issues: Tickets von Unterprojekten im Hauptprojekt anzeigen
               setting_emails_footer: E-Mail-Fußzeile
               setting_emails_header: E-Mail-Kopfzeile
               setting_enabled_scm: Aktivierte Versionskontrollsysteme
               setting_feeds_limit: Max. Anzahl Einträge pro Atom-Feed
               setting_file_max_size_displayed: Maximale Größe inline angezeigter Textdateien
               setting_force_default_language_for_anonymous: Standardsprache für anonyme Benutzer erzwingen
               setting_force_default_language_for_loggedin: Standardsprache für angemeldete Benutzer erzwingen
               setting_gantt_items_limit: Maximale Anzahl von Aufgaben die im Gantt-Chart angezeigt werden
               setting_gravatar_default: Standard-Gravatar-Bild
               setting_gravatar_enabled: Gravatar-Benutzerbilder benutzen
               setting_host_name: Hostname
               setting_issue_done_ratio: Berechne den Ticket-Fortschritt mittels
               setting_issue_done_ratio_issue_field: Ticket-Feld %-erledigt
               setting_issue_done_ratio_issue_status: Ticket-Status
               setting_issue_group_assignment: Ticketzuweisung an Gruppen erlauben
               setting_issue_list_default_columns: Standard-Spalten in der Ticket-Auflistung
               setting_issues_export_limit: Max. Anzahl Tickets bei CSV/PDF-Export
               setting_jsonp_enabled: JSONP Unterstützung aktivieren
               setting_link_copied_issue: Tickets beim kopieren verlinken
               setting_login_required: Authentifizierung erforderlich
               setting_mail_from: E-Mail-Absender
               setting_mail_handler_api_enabled: Abruf eingehender E-Mails aktivieren
               setting_mail_handler_api_key: API-Schlüssel
               setting_mail_handler_body_delimiters: "Schneide E-Mails nach einer dieser Zeilen ab"
               setting_mail_handler_excluded_filenames: Anhänge nach Namen ausschließen
               setting_new_project_user_role_id: Rolle, die einem Nicht-Administrator zugeordnet wird, der ein Projekt erstellt
               setting_non_working_week_days: Arbeitsfreie Tage
               setting_openid: Erlaube OpenID-Anmeldung und -Registrierung
               setting_password_min_length: Mindestlänge des Kennworts
+              setting_password_max_age: Erzwinge Passwortwechsel nach
               setting_per_page_options: Objekte pro Seite
               setting_plain_text_mail: Nur reinen Text (kein HTML) senden
               setting_protocol: Protokoll
               setting_repositories_encodings: Enkodierung von Anhängen und Repositories
               setting_repository_log_display_limit: Maximale Anzahl anzuzeigender Revisionen in der Historie einer Datei
               setting_rest_api_enabled: REST-Schnittstelle aktivieren
               setting_self_registration: Registrierung ermöglichen
               setting_sequential_project_identifiers: Fortlaufende Projektkennungen generieren
               setting_session_lifetime: Längste Dauer einer Sitzung
               setting_session_timeout: Zeitüberschreitung bei Inaktivität
               setting_start_of_week: Wochenanfang
               setting_sys_api_enabled: Webservice zur Verwaltung der Projektarchive benutzen
               setting_text_formatting: Textformatierung
               setting_thumbnails_enabled: Vorschaubilder von Dateianhängen anzeigen
               setting_thumbnails_size: Größe der Vorschaubilder (in Pixel)
               setting_time_format: Zeitformat
               setting_unsubscribe: Erlaubt Benutzern das eigene Benutzerkonto zu löschen
               setting_user_format: Benutzer-Anzeigeformat
               setting_welcome_text: Willkommenstext
               setting_wiki_compression: Wiki-Historie komprimieren
               status_active: aktiv
               status_locked: gesperrt
               status_registered: nicht aktivierte
               text_account_destroy_confirmation: "Möchten Sie wirklich fortfahren?\nIhr Benutzerkonto wird für immer gelöscht und kann nicht wiederhergestellt werden."
               text_are_you_sure: Sind Sie sicher?
               text_assign_time_entries_to_project: Gebuchte Aufwände dem Projekt zuweisen
               text_caracters_maximum: "Max. %{count} Zeichen."
               text_caracters_minimum: "Muss mindestens %{count} Zeichen lang sein."
               text_comma_separated: Mehrere Werte erlaubt (durch Komma getrennt).
               text_convert_available: ImageMagick Konvertierung verfügbar (optional)
               text_custom_field_possible_values_info: 'Eine Zeile pro Wert'
               text_default_administrator_account_changed: Administrator-Kennwort geändert
               text_destroy_time_entries: Gebuchte Aufwände löschen
               text_destroy_time_entries_question: Es wurden bereits %{hours} Stunden auf dieses Ticket gebucht. Was soll mit den Aufwänden geschehen?
               text_diff_truncated: '... Dieser Diff wurde abgeschnitten, weil er die maximale Anzahl anzuzeigender Zeilen überschreitet.'
               text_email_delivery_not_configured: "Der SMTP-Server ist nicht konfiguriert und Mailbenachrichtigungen sind ausgeschaltet.\nNehmen Sie die Einstellungen für Ihren SMTP-Server in config/configuration.yml vor und starten Sie die Applikation neu."
               text_enumeration_category_reassign_to: 'Die Objekte stattdessen diesem Wert zuordnen:'
               text_enumeration_destroy_question: "%{count} Objekt(e) sind diesem Wert zugeordnet."
               text_file_repository_writable: Verzeichnis für Dateien beschreibbar
               text_git_repository_note: Repository steht für sich alleine (bare) und liegt lokal (z.B. /gitrepo, c:\gitrepo)
               text_issue_added: "Ticket %{id} wurde erstellt von %{author}."
               text_issue_category_destroy_assignments: Kategorie-Zuordnung entfernen
               text_issue_category_destroy_question: "Einige Tickets (%{count}) sind dieser Kategorie zugeodnet. Was möchten Sie tun?"
               text_issue_category_reassign_to: Tickets dieser Kategorie zuordnen
               text_issue_conflict_resolution_add_notes: Meine Änderungen übernehmen und alle anderen Änderungen verwerfen
               text_issue_conflict_resolution_cancel: Meine Änderungen verwerfen und %{link} neu anzeigen
               text_issue_conflict_resolution_overwrite: Meine Änderungen trotzdem übernehmen (vorherige Notizen bleiben erhalten aber manche können überschrieben werden)
               text_issue_updated: "Ticket %{id} wurde aktualisiert von %{author}."
               text_issues_destroy_confirmation: 'Sind Sie sicher, dass Sie die ausgewählten Tickets löschen möchten?'
               text_issues_destroy_descendants_confirmation: Dies wird auch %{count} Unteraufgabe/n löschen.
               text_issues_ref_in_commit_messages: Ticket-Beziehungen und -Status in Commit-Log-Meldungen
               text_journal_added: "%{label} %{value} wurde hinzugefügt"
               text_journal_changed: "%{label} wurde von %{old} zu %{new} geändert"
               text_journal_changed_no_detail: "%{label} aktualisiert"
               text_journal_deleted: "%{label} %{old} wurde gelöscht"
               text_journal_set_to: "%{label} wurde auf %{value} gesetzt"
               text_length_between: "Länge zwischen %{min} und %{max} Zeichen."
               text_line_separated: Mehrere Werte sind erlaubt (eine Zeile pro Wert).
               text_load_default_configuration: Standard-Konfiguration laden
               text_mercurial_repository_note: Lokales repository (e.g. /hgrepo, c:\hgrepo)
               text_min_max_length_info: 0 heißt keine Beschränkung
               text_no_configuration_data: "Rollen, Tracker, Ticket-Status und Workflows wurden noch nicht konfiguriert.\nEs ist sehr zu empfehlen, die Standard-Konfiguration zu laden. Sobald sie geladen ist, können Sie diese abändern."
               text_own_membership_delete_confirmation: "Sie sind dabei, einige oder alle Ihre Berechtigungen zu entfernen. Es ist möglich, dass Sie danach das Projekt nicht mehr ansehen oder bearbeiten dürfen.\nSind Sie sicher, dass Sie dies tun möchten?"
               text_plugin_assets_writable: Verzeichnis für Plugin-Assets beschreibbar
               text_project_closed: Dieses Projekt ist geschlossen und kann nicht bearbeitet werden.
               text_project_destroy_confirmation: Sind Sie sicher, dass Sie das Projekt löschen wollen?
               text_project_identifier_info: 'Kleinbuchstaben (a-z), Ziffern, Binde- und Unterstriche erlaubt, muss mit einem Kleinbuchstaben beginnen.<br />Einmal gespeichert, kann die Kennung nicht mehr geändert werden.'
               text_reassign_time_entries: 'Gebuchte Aufwände diesem Ticket zuweisen:'
               text_regexp_info: z. B. ^[A-Z0-9]+$
               text_repository_identifier_info: 'Kleinbuchstaben (a-z), Ziffern, Binde- und Unterstriche erlaubt.<br />Einmal gespeichert, kann die Kennung nicht mehr geändert werden.'
               text_repository_usernames_mapping: "Bitte legen Sie die Zuordnung der Redmine-Benutzer zu den Benutzernamen der Commit-Log-Meldungen des Projektarchivs fest.\nBenutzer mit identischen Redmine- und Projektarchiv-Benutzernamen oder -E-Mail-Adressen werden automatisch zugeordnet."
               text_rmagick_available: RMagick verfügbar (optional)
               text_scm_command: Kommando
               text_scm_command_not_available: SCM-Kommando ist nicht verfügbar. Bitte prüfen Sie die Einstellungen im Administrationspanel.
               text_scm_command_version: Version
               text_scm_config: Die SCM-Kommandos können in der in config/configuration.yml konfiguriert werden. Redmine muss anschließend neu gestartet werden.
               text_scm_path_encoding_note: "Standard: UTF-8"
               text_select_mail_notifications: Bitte wählen Sie die Aktionen aus, für die eine Mailbenachrichtigung gesendet werden soll.
               text_select_project_modules: 'Bitte wählen Sie die Module aus, die in diesem Projekt aktiviert sein sollen:'
               text_session_expiration_settings: "Achtung: Änderungen können aktuelle Sitzungen beenden, Ihre eingeschlossen!"
               text_status_changed_by_changeset: "Status geändert durch Changeset %{value}."
               text_subprojects_destroy_warning: "Dessen Unterprojekte (%{value}) werden ebenfalls gelöscht."
               text_subversion_repository_note: 'Beispiele: file:///, http://, https://, svn://, svn+[tunnelscheme]://'
               text_time_entries_destroy_confirmation: Sind Sie sicher, dass Sie die ausgewählten Zeitaufwände löschen möchten?
               text_time_logged_by_changeset: Angewendet in Changeset %{value}.
               text_tip_issue_begin_day: Aufgabe, die an diesem Tag beginnt
               text_tip_issue_begin_end_day: Aufgabe, die an diesem Tag beginnt und endet
               text_tip_issue_end_day: Aufgabe, die an diesem Tag endet
               text_tracker_no_workflow: Kein Workflow für diesen Tracker definiert.
               text_turning_multiple_off: Wenn Sie die Mehrfachauswahl deaktivieren, werden Felder mit Mehrfachauswahl bereinigt.
                 Dadurch wird sichergestellt, dass lediglich ein Wert pro Feld ausgewählt ist.
               text_unallowed_characters: Nicht erlaubte Zeichen
               text_user_mail_option: "Für nicht ausgewählte Projekte werden Sie nur Benachrichtigungen für Dinge erhalten, die Sie beobachten oder an denen Sie beteiligt sind (z. B. Tickets, deren Autor Sie sind oder die Ihnen zugewiesen sind)."
               text_user_wrote: "%{value} schrieb:"
               text_warn_on_leaving_unsaved: Die aktuellen Änderungen gehen verloren, wenn Sie diese Seite verlassen.
               text_wiki_destroy_confirmation: Sind Sie sicher, dass Sie dieses Wiki mit sämtlichem Inhalt löschen möchten?
               text_wiki_page_destroy_children: Lösche alle Unterseiten
               text_wiki_page_destroy_question: "Diese Seite hat %{descendants} Unterseite(n). Was möchten Sie tun?"
               text_wiki_page_nullify_children: Verschiebe die Unterseiten auf die oberste Ebene
               text_wiki_page_reassign_children: Ordne die Unterseiten dieser Seite zu
               text_workflow_edit: Workflow zum Bearbeiten auswählen
               text_zoom_in: Ansicht vergrößern
               text_zoom_out: Ansicht verkleinern
               version_status_closed: abgeschlossen
               version_status_locked: gesperrt
               version_status_open: offen
               warning_attachments_not_saved: "%{count} Datei(en) konnten nicht gespeichert werden."
               label_search_attachments_yes: Namen und Beschreibungen von Anhängen durchsuchen
               label_search_attachments_no: Keine Anhänge suchen
               label_search_attachments_only: Nur Anhänge suchen
               label_search_open_issues_only: Nur offene Tickets
               field_address: E-Mail
               setting_max_additional_emails: Maximale Anzahl zusätzlicher E-Mailadressen
               label_email_address_plural: E-Mails
               label_email_address_add: E-Mailadresse hinzufügen
               label_enable_notifications: Benachrichtigungen aktivieren
               label_disable_notifications: Benachrichtigungen deaktivieren
               setting_search_results_per_page: Suchergebnisse pro Seite
               label_blank_value: leer
               permission_copy_issues: Tickets kopieren

config/locales/en.yml +2 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_hours:
                     one:   "1 hour"
                     other: "%{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: 3
                   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: "cannot be empty"
                     blank: "cannot 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"
                     earlier_than_minimum_start_date: "cannot be earlier than %{date} because of preceding issues"
               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_fontname: freesans
               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. An email containing the instructions to activate your account was sent to %{email}.
               notice_account_unknown_email: Unknown user.
               notice_account_not_activated_yet: You haven't activated your account yet. If you want to receive a new activation email, please <a href="%{url}">click this link</a>.
               notice_account_locked: Your account is locked.
               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 Atom access key was reset.
               notice_api_access_key_reseted: Your API access key was reset.
               notice_failed_to_save_issues: "Failed to save %{count} issue(s) on %{total} selected: %{ids}."
               notice_failed_to_save_time_entries: "Failed to save %{count} time entrie(s) on %{total} selected: %{ids}."
               notice_failed_to_save_members: "Failed to save member(s): %{errors}."
               notice_no_issue_selected: "No issue is selected! Please, check the issues you want to edit."
               notice_account_pending: "Your account was created and is now pending administrator approval."
               notice_default_data_loaded: Default configuration successfully loaded.
               notice_unable_delete_version: Unable to delete version.
               notice_unable_delete_time_entry: Unable to delete time log entry.
               notice_issue_done_ratios_updated: Issue done ratios updated.
               notice_gantt_chart_truncated: "The chart was truncated because it exceeds the maximum number of items that can be displayed (%{max})"
               notice_issue_successful_create: "Issue %{id} created."
               notice_issue_update_conflict: "The issue has been updated by an other user while you were editing it."
               notice_account_deleted: "Your account has been permanently deleted."
               notice_user_successful_create: "User %{id} created."
               notice_new_password_must_be_different: The new password must be different from the current password
               error_can_t_load_default_data: "Default configuration could not be loaded: %{value}"
               error_scm_not_found: "The entry or revision was not found in the repository."
               error_scm_command_failed: "An error occurred when trying to access the repository: %{value}"
               error_scm_annotate: "The entry does not exist or cannot be annotated."
               error_scm_annotate_big_text_file: "The entry cannot be annotated, as it exceeds the maximum text file size."
               error_issue_not_found_in_project: 'The issue was not found or does not belong to this project'
               error_no_tracker_in_project: 'No tracker is associated to this project. Please check the Project settings.'
               error_no_default_issue_status: 'No default issue status is defined. Please check your configuration (Go to "Administration -> Issue statuses").'
               error_can_not_delete_custom_field: Unable to delete custom field
               error_can_not_delete_tracker: "This tracker contains issues and cannot be deleted."
               error_can_not_remove_role: "This role is in use and cannot be deleted."
               error_can_not_reopen_issue_on_closed_version: 'An issue assigned to a closed version cannot be reopened'
               error_can_not_archive_project: This project cannot be archived
               error_issue_done_ratios_not_updated: "Issue done ratios not updated."
               error_workflow_copy_source: 'Please select a source tracker or role'
               error_workflow_copy_target: 'Please select target tracker(s) and role(s)'
               error_unable_delete_issue_status: 'Unable to delete issue status'
               error_unable_to_connect: "Unable to connect (%{value})"
               error_attachment_too_big: "This file cannot be uploaded because it exceeds the maximum allowed file size (%{max_size})"
               error_session_expired: "Your session has expired. Please login again."
               warning_attachments_not_saved: "%{count} file(s) could not be saved."
+              error_password_expired: "Your password has expired or the administrator requires you to change it."
               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}."
               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_address: Email
               field_filename: File
               field_filesize: Size
               field_downloads: Downloads
               field_author: Author
               field_created_on: Created
               field_updated_on: Updated
               field_closed_on: Closed
               field_field_format: Format
               field_is_for_all: For all projects
               field_possible_values: Possible values
               field_regexp: Regular expression
               field_min_length: Minimum length
               field_max_length: Maximum length
               field_value: Value
               field_category: Category
               field_title: Title
               field_project: Project
               field_issue: Issue
               field_status: Status
               field_notes: Notes
               field_is_closed: Issue closed
               field_is_default: Default value
               field_tracker: Tracker
               field_subject: Subject
               field_due_date: Due date
               field_assigned_to: Assignee
               field_priority: Priority
               field_fixed_version: Target version
               field_user: User
               field_principal: Principal
               field_role: Role
               field_homepage: Homepage
               field_is_public: Public
               field_parent: Subproject of
               field_is_in_roadmap: Issues displayed in roadmap
               field_login: Login
               field_mail_notification: Email notifications
               field_admin: Administrator
               field_last_login_on: Last connection
               field_language: Language
               field_effective_date: Date
               field_password: Password
               field_new_password: New password
               field_password_confirmation: Confirmation
               field_version: Version
               field_type: Type
               field_host: Host
               field_port: Port
               field_account: Account
               field_base_dn: Base DN
               field_attr_login: Login attribute
               field_attr_firstname: Firstname attribute
               field_attr_lastname: Lastname attribute
               field_attr_mail: Email attribute
               field_onthefly: On-the-fly user creation
               field_start_date: Start date
               field_done_ratio: "% Done"
               field_auth_source: Authentication mode
               field_hide_mail: Hide my email address
               field_comments: Comment
               field_url: URL
               field_start_page: Start page
               field_subproject: Subproject
               field_hours: Hours
               field_activity: Activity
               field_spent_on: Date
               field_identifier: Identifier
               field_is_filter: Used as a filter
               field_issue_to: Related issue
               field_delay: Delay
               field_assignable: Issues can be assigned to this role
               field_redirect_existing_links: Redirect existing links
               field_estimated_hours: Estimated time
               field_column_names: Columns
               field_time_entries: Log time
               field_time_zone: Time zone
               field_searchable: Searchable
               field_default_value: Default value
               field_comments_sorting: Display comments
               field_parent_title: Parent page
               field_editable: Editable
               field_watcher: Watcher
               field_identity_url: OpenID URL
               field_content: Content
               field_group_by: Group results by
               field_sharing: Sharing
               field_parent_issue: Parent task
               field_member_of_group: "Assignee's group"
               field_assigned_to_role: "Assignee's role"
               field_text: Text field
               field_visible: Visible
               field_warn_on_leaving_unsaved: "Warn me when leaving a page with unsaved text"
               field_issues_visibility: Issues visibility
               field_is_private: Private
               field_commit_logs_encoding: Commit messages encoding
               field_scm_path_encoding: Path encoding
               field_path_to_repository: Path to repository
               field_root_directory: Root directory
               field_cvsroot: CVSROOT
               field_cvs_module: Module
               field_repository_is_default: Main repository
               field_multiple: Multiple values
               field_auth_source_ldap_filter: LDAP filter
               field_core_fields: Standard fields
               field_timeout: "Timeout (in seconds)"
               field_board_parent: Parent forum
               field_private_notes: Private notes
               field_inherit_members: Inherit members
               field_generate_password: Generate password
               field_must_change_passwd: Must change password at next logon
               field_default_status: Default status
               field_users_visibility: Users 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: Maximum attachment size
               setting_issues_export_limit: Issues export limit
               setting_mail_from: Emission email address
               setting_bcc_recipients: Blind carbon copy recipients (bcc)
               setting_plain_text_mail: Plain text mail (no HTML)
               setting_host_name: Host name and path
               setting_text_formatting: Text formatting
               setting_wiki_compression: Wiki history compression
               setting_feeds_limit: Maximum number of items in Atom feeds
               setting_default_projects_public: New projects are public by default
               setting_autofetch_changesets: Fetch commits automatically
               setting_sys_api_enabled: Enable WS for repository management
               setting_commit_ref_keywords: Referencing keywords
               setting_commit_fix_keywords: Fixing keywords
               setting_autologin: Autologin
               setting_date_format: Date format
               setting_time_format: Time format
               setting_cross_project_issue_relations: Allow cross-project issue relations
               setting_cross_project_subtasks: Allow cross-project subtasks
               setting_issue_list_default_columns: Default columns displayed on the issue list
               setting_repositories_encodings: Attachments and repositories encodings
               setting_emails_header: Email header
               setting_emails_footer: Email footer
               setting_protocol: Protocol
               setting_per_page_options: Objects per page options
               setting_user_format: Users display format
               setting_activity_days_default: Days displayed on project activity
               setting_display_subprojects_issues: Display subprojects issues on main projects by default
               setting_enabled_scm: Enabled SCM
               setting_mail_handler_body_delimiters: "Truncate emails after one of these lines"
               setting_mail_handler_api_enabled: Enable WS for incoming emails
               setting_mail_handler_api_key: API key
               setting_sequential_project_identifiers: Generate sequential project identifiers
               setting_gravatar_enabled: Use Gravatar user icons
               setting_gravatar_default: Default Gravatar image
               setting_diff_max_lines_displayed: Maximum number of diff lines displayed
               setting_file_max_size_displayed: Maximum size of text files displayed inline
               setting_repository_log_display_limit: Maximum number of revisions displayed on file log
               setting_openid: Allow OpenID login and registration
+              setting_password_max_age: Require password change after
               setting_password_min_length: Minimum password length
               setting_new_project_user_role_id: Role given to a non-admin user who creates a project
               setting_default_projects_modules: Default enabled modules for new projects
               setting_issue_done_ratio: Calculate the issue done ratio with
               setting_issue_done_ratio_issue_field: Use the issue field
               setting_issue_done_ratio_issue_status: Use the issue status
               setting_start_of_week: Start calendars on
               setting_rest_api_enabled: Enable REST web service
               setting_cache_formatted_text: Cache formatted text
               setting_default_notification_option: Default notification option
               setting_commit_logtime_enabled: Enable time logging
               setting_commit_logtime_activity_id: Activity for logged time
               setting_gantt_items_limit: Maximum number of items displayed on the gantt chart
               setting_issue_group_assignment: Allow issue assignment to groups
               setting_default_issue_start_date_to_creation_date: Use current date as start date for new issues
               setting_commit_cross_project_ref: Allow issues of all the other projects to be referenced and fixed
               setting_unsubscribe: Allow users to delete their own account
               setting_session_lifetime: Session maximum lifetime
               setting_session_timeout: Session inactivity timeout
               setting_thumbnails_enabled: Display attachment thumbnails
               setting_thumbnails_size: Thumbnails size (in pixels)
               setting_non_working_week_days: Non-working days
               setting_jsonp_enabled: Enable JSONP support
               setting_default_projects_tracker_ids: Default trackers for new projects
               setting_mail_handler_excluded_filenames: Exclude attachments by name
               setting_force_default_language_for_anonymous: Force default language for anonymous users
               setting_force_default_language_for_loggedin: Force default language for logged-in users
               setting_link_copied_issue: Link issues on copy
               setting_max_additional_emails: Maximum number of additional email addresses
               setting_search_results_per_page: Search results per page
               permission_add_project: Create project
               permission_add_subprojects: Create subprojects
               permission_edit_project: Edit project
               permission_close_project: Close / reopen the 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_copy_issues: Copy issues
               permission_manage_issue_relations: Manage issue relations
               permission_set_issues_private: Set issues public or private
               permission_set_own_issues_private: Set own issues public or private
               permission_add_issue_notes: Add notes
               permission_edit_issue_notes: Edit notes
               permission_edit_own_issue_notes: Edit own notes
               permission_view_private_notes: View private notes
               permission_set_notes_private: Set notes as private
               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_view_documents: View documents
               permission_add_documents: Add documents
               permission_edit_documents: Edit documents
               permission_delete_documents: Delete documents
               permission_manage_files: Manage files
               permission_view_files: View files
               permission_manage_wiki: Manage wiki
               permission_rename_wiki_pages: Rename wiki pages
               permission_delete_wiki_pages: Delete wiki pages
               permission_view_wiki_pages: View wiki
               permission_view_wiki_edits: View wiki history
               permission_edit_wiki_pages: Edit wiki pages
               permission_delete_wiki_pages_attachments: Delete attachments
               permission_protect_wiki_pages: Protect wiki pages
               permission_manage_repository: Manage repository
               permission_browse_repository: Browse repository
               permission_view_changesets: View changesets
               permission_commit_access: Commit access
               permission_manage_boards: Manage forums
               permission_view_messages: View messages
               permission_add_messages: Post messages
               permission_edit_messages: Edit messages
               permission_edit_own_messages: Edit own messages
               permission_delete_messages: Delete messages
               permission_delete_own_messages: Delete own messages
               permission_export_wiki_pages: Export wiki pages
               permission_manage_subtasks: Manage subtasks
               permission_manage_related_issues: Manage related issues
               project_module_issue_tracking: Issue tracking
               project_module_time_tracking: Time tracking
               project_module_news: News
               project_module_documents: Documents
               project_module_files: Files
               project_module_wiki: Wiki
               project_module_repository: Repository
               project_module_boards: Forums
               project_module_calendar: Calendar
               project_module_gantt: Gantt
               label_user: User
               label_user_plural: Users
               label_user_new: New user
               label_user_anonymous: Anonymous
               label_project: Project
               label_project_new: New project
               label_project_plural: Projects
               label_x_projects:
                 zero:  no projects
                 one:   1 project
                 other: "%{count} projects"
               label_project_all: All Projects
               label_project_latest: Latest projects
               label_issue: Issue
               label_issue_new: New issue
               label_issue_plural: Issues
               label_issue_view_all: View all issues
               label_issues_by: "Issues by %{value}"
               label_issue_added: Issue added
               label_issue_updated: Issue updated
               label_issue_note_added: Note added
               label_issue_status_updated: Status updated
               label_issue_assigned_to_updated: Assignee 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_no_data: No data to display
               label_change_status: Change status
               label_history: History
               label_attachment: File
               label_attachment_new: New file
               label_attachment_delete: Delete file
               label_attachment_plural: Files
               label_file_added: File added
               label_report: Report
               label_report_plural: Reports
               label_news: News
               label_news_new: Add news
               label_news_plural: News
               label_news_latest: Latest news
               label_news_view_all: View all news
               label_news_added: News added
               label_news_comment_added: Comment added to a news
               label_settings: Settings
               label_overview: Overview
               label_version: Version
               label_version_new: New version
               label_version_plural: Versions
               label_close_versions: Close completed versions
               label_confirmation: Confirmation
               label_export_to: 'Also available in:'
               label_read: Read...
               label_public_projects: Public projects
               label_open_issues: open
               label_open_issues_plural: open
               label_closed_issues: closed
               label_closed_issues_plural: closed
               label_x_open_issues_abbr_on_total:
                 zero:  0 open / %{total}
                 one:   1 open / %{total}
                 other: "%{count} open / %{total}"
               label_x_open_issues_abbr:
                 zero:  0 open
                 one:   1 open
                 other: "%{count} open"
               label_x_closed_issues_abbr:
                 zero:  0 closed
                 one:   1 closed
                 other: "%{count} closed"
               label_x_issues:
                 zero:  0 issues
                 one:   1 issue
                 other: "%{count} issues"
               label_total: Total
               label_total_time: Total time
               label_permissions: Permissions
               label_current_status: Current status
               label_new_statuses_allowed: New statuses allowed
               label_all: all
               label_any: any
               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_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_in_the_next_days: in the next
               label_in_the_past_days: in the past
               label_greater_or_equal: '>='
               label_less_or_equal: '<='
               label_between: between
               label_in: in
               label_today: today
               label_all_time: all time
               label_yesterday: yesterday
               label_this_week: this week
               label_last_week: last week
               label_last_n_weeks: "last %{count} weeks"
               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_any_issues_in_project: any issues in project
               label_any_issues_not_in_project: any issues not in project
               label_no_issues_in_project: no issues in project
               label_day_plural: days
               label_repository: Repository
               label_repository_new: New repository
               label_repository_plural: Repositories
               label_browse: Browse
               label_branch: Branch
               label_tag: Tag
               label_revision: Revision
               label_revision_plural: Revisions
               label_revision_id: "Revision %{value}"
               label_associated_revisions: Associated revisions
               label_added: added
               label_modified: modified
               label_copied: copied
               label_renamed: renamed
               label_deleted: deleted
               label_latest_revision: Latest revision
               label_latest_revision_plural: Latest revisions
               label_view_revisions: View revisions
               label_view_all_revisions: View all revisions
               label_max_size: Maximum size
               label_sort_highest: Move to top
               label_sort_higher: Move up
               label_sort_lower: Move down
               label_sort_lowest: Move to bottom
               label_roadmap: Roadmap
               label_roadmap_due_in: "Due in %{value}"
               label_roadmap_overdue: "%{value} late"
               label_roadmap_no_issues: No issues for this version
               label_search: Search
               label_result_plural: Results
               label_all_words: All words
               label_wiki: Wiki
               label_wiki_edit: Wiki edit
               label_wiki_edit_plural: Wiki edits
               label_wiki_page: Wiki page
               label_wiki_page_plural: Wiki pages
               label_index_by_title: Index by title
               label_index_by_date: Index by date
               label_current_version: Current version
               label_preview: Preview
               label_feed_plural: Feeds
               label_changes_details: Details of all changes
               label_issue_tracking: Issue tracking
               label_spent_time: Spent time
               label_overall_spent_time: Overall spent time
               label_f_hour: "%{value} hour"
               label_f_hour_plural: "%{value} hours"
               label_time_tracking: Time tracking
               label_change_plural: Changes
               label_statistics: Statistics
               label_commits_per_month: Commits per month
               label_commits_per_author: Commits per author
               label_diff: diff
               label_view_diff: View differences
               label_diff_inline: inline
               label_diff_side_by_side: side by side
               label_options: Options
               label_copy_workflow_from: Copy workflow from
               label_permissions_report: Permissions report
               label_watched_issues: Watched issues
               label_related_issues: Related issues
               label_applied_status: Applied status
               label_loading: Loading...
               label_relation_new: New relation
               label_relation_delete: Delete relation
               label_relates_to: Related to
               label_duplicates: Duplicates
               label_duplicated_by: Duplicated by
               label_blocks: Blocks
               label_blocked_by: Blocked by
               label_precedes: Precedes
               label_follows: Follows
               label_copied_to: Copied to
               label_copied_from: Copied from
               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: Atom access key
               label_missing_feeds_access_key: Missing a Atom access key
               label_feeds_access_key_created_on: "Atom 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_group_anonymous: Anonymous users
               label_group_non_member: Non member users
               label_time_entry_plural: Spent time
               label_version_sharing_none: Not shared
               label_version_sharing_descendants: With subprojects
               label_version_sharing_hierarchy: With project hierarchy
               label_version_sharing_tree: With project tree
               label_version_sharing_system: With all projects
               label_update_issue_done_ratios: Update issue done ratios
               label_copy_source: Source
               label_copy_target: Target
               label_copy_same_as_target: Same as target
               label_display_used_statuses_only: Only display statuses that are used by this tracker
               label_api_access_key: API access key
               label_missing_api_access_key: Missing an API access key
               label_api_access_key_created_on: "API access key created %{value} ago"
               label_profile: Profile
               label_subtask_plural: Subtasks
               label_project_copy_notifications: Send email notifications during the project copy
               label_principal_search: "Search for user or group:"
               label_user_search: "Search for user:"
               label_additional_workflow_transitions_for_author: Additional transitions allowed when the user is the author
               label_additional_workflow_transitions_for_assignee: Additional transitions allowed when the user is the assignee
               label_issues_visibility_all: All issues
               label_issues_visibility_public: All non private issues
               label_issues_visibility_own: Issues created by or assigned to the user
               label_git_report_last_commit: Report last commit for files and directories
               label_parent_revision: Parent
               label_child_revision: Child
               label_export_options: "%{export_format} export options"
               label_copy_attachments: Copy attachments
               label_copy_subtasks: Copy subtasks
               label_item_position: "%{position} of %{count}"
               label_completed_versions: Completed versions
               label_search_for_watchers: Search for watchers to add
               label_session_expiration: Session expiration
               label_show_closed_projects: View closed projects
               label_status_transitions: Status transitions
               label_fields_permissions: Fields permissions
               label_readonly: Read-only
               label_required: Required
               label_hidden: Hidden
               label_attribute_of_project: "Project's %{name}"
               label_attribute_of_issue: "Issue's %{name}"
               label_attribute_of_author: "Author's %{name}"
               label_attribute_of_assigned_to: "Assignee's %{name}"
               label_attribute_of_user: "User's %{name}"
               label_attribute_of_fixed_version: "Target version's %{name}"
               label_cross_project_descendants: With subprojects
               label_cross_project_tree: With project tree
               label_cross_project_hierarchy: With project hierarchy
               label_cross_project_system: With all projects
               label_gantt_progress_line: Progress line
               label_visibility_private: to me only
               label_visibility_roles: to these roles only
               label_visibility_public: to any users
               label_link: Link
               label_only: only
               label_drop_down_list: drop-down list
               label_checkboxes: checkboxes
               label_radio_buttons: radio buttons
               label_link_values_to: Link values to URL
               label_custom_field_select_type: Select the type of object to which the custom field is to be attached
               label_check_for_updates: Check for updates
               label_latest_compatible_version: Latest compatible version
               label_unknown_plugin: Unknown plugin
               label_add_projects: Add projects
               label_users_visibility_all: All active users
               label_users_visibility_members_of_visible_projects: Members of visible projects
               label_edit_attachments: Edit attached files
               label_link_copied_issue: Link copied issue
               label_ask: Ask
               label_search_attachments_yes: Search attachment filenames and descriptions
               label_search_attachments_no: Do not search attachments
               label_search_attachments_only: Search attachments only
               label_search_open_issues_only: Open issues only
               label_email_address_plural: Emails
               label_email_address_add: Add email address
               label_enable_notifications: Enable notifications
               label_disable_notifications: Disable notifications
               label_blank_value: blank
               button_login: Login
               button_submit: Submit
               button_save: Save
               button_check_all: Check all
               button_uncheck_all: Uncheck all
               button_collapse_all: Collapse all
               button_expand_all: Expand all
               button_delete: Delete
               button_create: Create
               button_create_and_continue: Create and continue
               button_test: Test
               button_edit: Edit
               button_edit_associated_wikipage: "Edit associated Wiki page: %{page_title}"
               button_add: Add
               button_change: Change
               button_apply: Apply
               button_clear: Clear
               button_lock: Lock
               button_unlock: Unlock
               button_download: Download
               button_list: List
               button_view: View
               button_move: Move
               button_move_and_follow: Move and follow
               button_back: Back
               button_cancel: Cancel
               button_activate: Activate
               button_sort: Sort
               button_log_time: Log time
               button_rollback: Rollback to this version
               button_watch: Watch
               button_unwatch: Unwatch
               button_reply: Reply
               button_archive: Archive
               button_unarchive: Unarchive
               button_reset: Reset
               button_rename: Rename
               button_change_password: Change password
               button_copy: Copy
               button_copy_and_follow: Copy and follow
               button_annotate: Annotate
               button_update: Update
               button_configure: Configure
               button_quote: Quote
               button_duplicate: Duplicate
               button_show: Show
               button_hide: Hide
               button_edit_section: Edit this section
               button_export: Export
               button_delete_my_account: Delete my account
               button_close: Close
               button_reopen: Reopen
               status_active: active
               status_registered: registered
               status_locked: locked
               project_status_active: active
               project_status_closed: closed
               project_status_archived: archived
               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_journal_changed: "%{label} changed from %{old} to %{new}"
               text_journal_changed_no_detail: "%{label} updated"
               text_journal_set_to: "%{label} set to %{value}"
               text_journal_deleted: "%{label} deleted (%{old})"
               text_journal_added: "%{label} %{value} added"
               text_tip_issue_begin_day: issue beginning this day
               text_tip_issue_end_day: issue ending this day
               text_tip_issue_begin_end_day: issue beginning and ending this day
               text_project_identifier_info: 'Only lower case letters (a-z), numbers, dashes and underscores are allowed, must start with a lower case letter.<br />Once saved, the identifier cannot be changed.'
               text_caracters_maximum: "%{count} characters maximum."
               text_caracters_minimum: "Must be at least %{count} characters long."
               text_length_between: "Length between %{min} and %{max} characters."
               text_tracker_no_workflow: No workflow defined for this tracker
               text_unallowed_characters: Unallowed characters
               text_comma_separated: Multiple values allowed (comma separated).
               text_line_separated: Multiple values allowed (one line for each value).
               text_issues_ref_in_commit_messages: Referencing and fixing issues in commit messages
               text_issue_added: "Issue %{id} has been reported by %{author}."
               text_issue_updated: "Issue %{id} has been updated by %{author}."
               text_wiki_destroy_confirmation: Are you sure you want to delete this wiki and all its content?
               text_issue_category_destroy_question: "Some issues (%{count}) are assigned to this category. What do you want to do?"
               text_issue_category_destroy_assignments: Remove category assignments
               text_issue_category_reassign_to: Reassign issues to this category
               text_user_mail_option: "For unselected projects, you will only receive notifications about things you watch or you're involved in (eg. issues you're the author or assignee)."
               text_no_configuration_data: "Roles, trackers, issue statuses and workflow have not been configured yet.\nIt is highly recommended to load the default configuration. You will be able to modify it once loaded."
               text_load_default_configuration: Load the default configuration
               text_status_changed_by_changeset: "Applied in changeset %{value}."
               text_time_logged_by_changeset: "Applied in changeset %{value}."
               text_issues_destroy_confirmation: 'Are you sure you want to delete the selected issue(s)?'
               text_issues_destroy_descendants_confirmation: "This will also delete %{count} subtask(s)."
               text_time_entries_destroy_confirmation: 'Are you sure you want to delete the selected time entr(y/ies)?'
               text_select_project_modules: 'Select modules to enable for this project:'
               text_default_administrator_account_changed: Default administrator account changed
               text_file_repository_writable: Attachments directory writable
               text_plugin_assets_writable: Plugin assets directory writable
               text_rmagick_available: RMagick available (optional)
               text_convert_available: ImageMagick convert available (optional)
               text_destroy_time_entries_question: "%{hours} hours were reported on the issues you are about to delete. What do you want to do?"
               text_destroy_time_entries: Delete reported hours
               text_assign_time_entries_to_project: Assign reported hours to the project
               text_reassign_time_entries: 'Reassign reported hours to this issue:'
               text_user_wrote: "%{value} wrote:"
               text_enumeration_destroy_question: "%{count} objects are assigned to this value."
               text_enumeration_category_reassign_to: 'Reassign them to this value:'
               text_email_delivery_not_configured: "Email delivery is not configured, and notifications are disabled.\nConfigure your SMTP server in config/configuration.yml and restart the application to enable them."
               text_repository_usernames_mapping: "Select or update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
               text_diff_truncated: '... This diff was truncated because it exceeds the maximum size that can be displayed.'
               text_custom_field_possible_values_info: 'One line for each value'
               text_wiki_page_destroy_question: "This page has %{descendants} child page(s) and descendant(s). What do you want to do?"
               text_wiki_page_nullify_children: "Keep child pages as root pages"
               text_wiki_page_destroy_children: "Delete child pages and all their descendants"
               text_wiki_page_reassign_children: "Reassign child pages to this parent page"
               text_own_membership_delete_confirmation: "You are about to remove some or all of your permissions and may no longer be able to edit this project after that.\nAre you sure you want to continue?"
               text_zoom_in: Zoom in
               text_zoom_out: Zoom out
               text_warn_on_leaving_unsaved: "The current page contains unsaved text that will be lost if you leave this page."
               text_scm_path_encoding_note: "Default: UTF-8"
               text_subversion_repository_note: "Examples: file:///, http://, https://, svn://, svn+[tunnelscheme]://"
               text_git_repository_note: Repository is bare and local (e.g. /gitrepo, c:\gitrepo)
               text_mercurial_repository_note: Local repository (e.g. /hgrepo, c:\hgrepo)
               text_scm_command: Command
               text_scm_command_version: Version
               text_scm_config: You can configure your SCM commands in config/configuration.yml. Please restart the application after editing it.
               text_scm_command_not_available: SCM command is not available. Please check settings on the administration panel.
               text_issue_conflict_resolution_overwrite: "Apply my changes anyway (previous notes will be kept but some changes may be overwritten)"
               text_issue_conflict_resolution_add_notes: "Add my notes and discard my other changes"
               text_issue_conflict_resolution_cancel: "Discard all my changes and redisplay %{link}"
               text_account_destroy_confirmation: "Are you sure you want to proceed?\nYour account will be permanently deleted, with no way to reactivate it."
               text_session_expiration_settings: "Warning: changing these settings may expire the current sessions including yours."
               text_project_closed: This project is closed and read-only.
               text_turning_multiple_off: "If you disable multiple values, multiple values will be removed in order to preserve only one value per item."
               default_role_manager: Manager
               default_role_developer: Developer
               default_role_reporter: Reporter
               default_tracker_bug: Bug
               default_tracker_feature: Feature
               default_tracker_support: Support
               default_issue_status_new: New
               default_issue_status_in_progress: In Progress
               default_issue_status_resolved: Resolved
               default_issue_status_feedback: Feedback
               default_issue_status_closed: Closed
               default_issue_status_rejected: Rejected
               default_doc_category_user: User documentation
               default_doc_category_tech: Technical documentation
               default_priority_low: Low
               default_priority_normal: Normal
               default_priority_high: High
               default_priority_urgent: Urgent
               default_priority_immediate: Immediate
               default_activity_design: Design
               default_activity_development: Development
               enumeration_issue_priorities: Issue priorities
               enumeration_doc_categories: Document categories
               enumeration_activities: Activities (time tracking)
               enumeration_system_activity: System Activity
               description_filter: Filter
               description_search: Searchfield
               description_choose_project: Projects
               description_project_scope: Search scope
               description_notes: Notes
               description_message_content: Message content
               description_query_sort_criteria_attribute: Sort attribute
               description_query_sort_criteria_direction: Sort direction
               description_user_mail_notification: Mail notification settings
               description_available_columns: Available Columns
               description_selected_columns: Selected Columns
               description_all_columns: All Columns
               description_issue_category_reassign: Choose issue category
               description_wiki_subpages_reassign: Choose new parent page
               description_date_range_list: Choose range from list
               description_date_range_interval: Choose range by selecting start and end date
               description_date_from: Enter start date
               description_date_to: Enter end date
               text_repository_identifier_info: 'Only lower case letters (a-z), numbers, dashes and underscores are allowed.<br />Once saved, the identifier cannot be changed.'

config/locales/fr.yml +2 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]
                 # Don't forget the nil at the beginning; there's no such thing as a 0th month
                 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.]
                 # Used in date_select and datime_select.
                 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_hours:
                     one:   "une heure"
                     other: "%{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: 3
                   storage_units:
                     format: "%n %u"
                     units:
                       byte:
                         one: "octet"
                         other: "octets"
                       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"
                     earlier_than_minimum_start_date: "ne peut pas être antérieure au %{date} à cause des demandes qui précèdent"
               actionview_instancetag_blank_option: Choisir
               general_text_No: 'Non'
               general_text_Yes: 'Oui'
               general_text_no: 'non'
               general_text_yes: 'oui'
               general_lang_name: 'French (Français)'
               general_csv_separator: ';'
               general_csv_decimal_separator: ','
               general_csv_encoding: ISO-8859-1
               general_pdf_fontname: freesans
               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é à l'adresse %{email}.
               notice_account_unknown_email: Aucun compte ne correspond à cette adresse.
               notice_account_not_activated_yet: Vous n'avez pas encore activé votre compte. Si vous voulez recevoir un nouveau message d'activation, veuillez <a href="%{url}">cliquer sur ce lien</a>.
               notice_account_locked: Votre compte est verrouillé.
               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 Atom a été réinitialisée."
               notice_api_access_key_reseted: Votre clé d'accès API 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_failed_to_save_time_entries: "%{count} temps passé(s) sur les %{total} sélectionnés n'ont pas pu être mis à jour: %{ids}."
               notice_failed_to_save_members: "Erreur lors de la sauvegarde des membres: %{errors}."
               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_unable_delete_time_entry: Impossible de supprimer le temps passé.
               notice_issue_done_ratios_updated: L'avancement des demandes a été mis à jour.
               notice_gantt_chart_truncated: "Le diagramme a été tronqué car il excède le nombre maximal d'éléments pouvant être affichés (%{max})"
               notice_issue_successful_create: "Demande %{id} créée."
               notice_issue_update_conflict: "La demande a été mise à jour par un autre utilisateur pendant que vous la modifiez."
               notice_account_deleted: "Votre compte a été définitivement supprimé."
               notice_user_successful_create: "Utilisateur %{id} créé."
               notice_new_password_must_be_different: Votre nouveau mot de passe doit être différent de votre mot de passe actuel
               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_scm_annotate_big_text_file: Cette entrée ne peut pas être annotée car elle excède la taille maximale.
               error_issue_not_found_in_project: "La demande n'existe pas ou n'appartient pas à ce projet"
               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)."
               error_can_not_delete_custom_field: Impossible de supprimer le champ personnalisé
               error_can_not_delete_tracker: Ce tracker contient des demandes et ne peut pas être supprimé.
               error_can_not_remove_role: Ce rôle est utilisé et ne peut pas être supprimé.
               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_issue_done_ratios_not_updated: L'avancement des demandes n'a pas pu être mis à jour.
               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_unable_delete_issue_status: Impossible de supprimer le statut de demande
               error_unable_to_connect: Connexion impossible (%{value})
               error_attachment_too_big: Ce fichier ne peut pas être attaché car il excède la taille maximale autorisée (%{max_size})
               error_session_expired: "Votre session a expiré. Veuillez vous reconnecter."
               warning_attachments_not_saved: "%{count} fichier(s) n'ont pas pu être sauvegardés."
+              error_password_expired: "Votre mot de passe a expiré ou nécessite d'être changé."
               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}."
               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_address: 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_closed_on: Fermé
               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_principal: Principal
               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_entries: Temps passé
               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_parent_issue: Tâche parente
               field_member_of_group: Groupe de l'assigné
               field_assigned_to_role: Rôle de l'assigné
               field_text: Champ texte
               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
               field_is_private: Privée
               field_commit_logs_encoding: Encodage des messages de commit
               field_scm_path_encoding: Encodage des chemins
               field_path_to_repository: Chemin du dépôt
               field_root_directory: Répertoire racine
               field_cvsroot: CVSROOT
               field_cvs_module: Module
               field_repository_is_default: Dépôt principal
               field_multiple: Valeurs multiples
               field_auth_source_ldap_filter: Filtre LDAP
               field_core_fields: Champs standards
               field_timeout: "Timeout (en secondes)"
               field_board_parent: Forum parent
               field_private_notes: Notes privées
               field_inherit_members: Hériter les membres
               field_generate_password: Générer un mot de passe
               field_must_change_passwd: Doit changer de mot de passe à la prochaine connexion
               field_default_status: Statut par défaut
               field_users_visibility: Visibilité des utilisateurs
               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 maximale des fichiers
               setting_issues_export_limit: Limite d'exportation des demandes
               setting_mail_from: Adresse d'émission
               setting_bcc_recipients: Destinataires en copie cachée (cci)
               setting_plain_text_mail: Mail en texte brut (non HTML)
               setting_host_name: Nom d'hôte et chemin
               setting_text_formatting: Formatage du texte
               setting_wiki_compression: Compression de l'historique des pages wiki
               setting_feeds_limit: Nombre maximal d'éléments dans les flux Atom
               setting_default_projects_public: Définir les nouveaux projets comme publics par défaut
               setting_autofetch_changesets: Récupération automatique 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: Durée maximale de connexion automatique
               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_cross_project_subtasks: Autoriser les sous-tâches dans des projets différents
               setting_issue_list_default_columns: Colonnes affichées par défaut sur la liste des demandes
               setting_repositories_encodings: Encodages des fichiers et des dépôts
               setting_emails_header: En-tête des emails
               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_gravatar_default: Image Gravatar par défaut
               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_max_age: Expiration des mots de passe après
               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_field: 'Utiliser le champ % effectué'
               setting_issue_done_ratio_issue_status: Utiliser le statut
               setting_start_of_week: Jour de début des calendriers
               setting_rest_api_enabled: Activer l'API REST
               setting_cache_formatted_text: Mettre en cache le texte formaté
               setting_default_notification_option: Option de notification par défaut
               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
               setting_issue_group_assignment: Permettre l'assignement des demandes aux groupes
               setting_default_issue_start_date_to_creation_date: Donner à la date de début d'une nouvelle demande la valeur de la date du jour
               setting_commit_cross_project_ref: Permettre le référencement et la résolution des demandes de tous les autres projets
               setting_unsubscribe: Permettre aux utilisateurs de supprimer leur propre compte
               setting_session_lifetime: Durée de vie maximale des sessions
               setting_session_timeout: Durée maximale d'inactivité
               setting_thumbnails_enabled: Afficher les vignettes des images
               setting_thumbnails_size: Taille des vignettes (en pixels)
               setting_non_working_week_days: Jours non travaillés
               setting_jsonp_enabled: Activer le support JSONP
               setting_default_projects_tracker_ids: Trackers par défaut pour les nouveaux projets
               setting_mail_handler_excluded_filenames: Exclure les fichiers attachés par leur nom
               setting_force_default_language_for_anonymous: Forcer la langue par défault pour les utilisateurs anonymes
               setting_force_default_language_for_loggedin: Forcer la langue par défault pour les utilisateurs identifiés
               setting_link_copied_issue: Lier les demandes lors de la copie
               setting_max_additional_emails: Nombre maximal d'adresses email additionnelles
               setting_search_results_per_page: Résultats de recherche affichés par page
               permission_add_project: Créer un projet
               permission_add_subprojects: Créer des sous-projets
               permission_edit_project: Modifier le projet
               permission_close_project: Fermer / réouvrir le projet
               permission_select_project_modules: Choisir les modules
               permission_manage_members: Gérer les membres
               permission_manage_project_activities: Gérer les activités
               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_copy_issues: Copier les demandes
               permission_manage_issue_relations: Gérer les relations
               permission_set_issues_private: Rendre les demandes publiques ou privées
               permission_set_own_issues_private: Rendre ses propres demandes publiques ou privées
               permission_add_issue_notes: Ajouter des notes
               permission_edit_issue_notes: Modifier les notes
               permission_edit_own_issue_notes: Modifier ses propres notes
               permission_view_private_notes: Voir les notes privées
               permission_set_notes_private: Rendre les notes privées
               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_view_documents: Voir les documents
               permission_add_documents: Ajouter des documents
               permission_edit_documents: Modifier les documents
               permission_delete_documents: Supprimer 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_subtasks: Gérer les sous-tâches
               permission_manage_related_issues: Gérer les demandes associées
               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
               project_module_calendar: Calendrier
               project_module_gantt: Gantt
               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_issues_by: "Demandes par %{value}"
               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_assigned_to_updated: Assigné changé
               label_issue_priority_updated: Priorité changée
               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_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_close_versions: Fermer les versions terminées
               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 ouverte sur %{total}
                 one:   1 ouverte sur %{total}
                 other: "%{count} ouvertes sur %{total}"
               label_x_open_issues_abbr:
                 zero:  0 ouverte
                 one:   1 ouverte
                 other: "%{count} ouvertes"
               label_x_closed_issues_abbr:
                 zero:  0 fermée
                 one:   1 fermée
                 other: "%{count} fermées"
               label_x_issues:
                 zero:  0 demande
                 one:   1 demande
                 other: "%{count} demandes"
               label_total: Total
               label_total_time: Temps total
               label_permissions: Permissions
               label_current_status: Statut actuel
               label_new_statuses_allowed: Nouveaux statuts autorisés
               label_all: tous
               label_any: 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_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_the_next_days: dans les prochains jours
               label_in_the_past_days: dans les derniers jours
               label_greater_or_equal: '>='
               label_less_or_equal: '<='
               label_between: entre
               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_weeks: "les %{count} dernières semaines"
               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_any_issues_in_project: une demande du projet
               label_any_issues_not_in_project: une demande hors du projet
               label_no_issues_in_project: aucune demande du projet
               label_day_plural: jours
               label_repository: Dépôt
               label_repository_new: Nouveau dépôt
               label_repository_plural: Dépôts
               label_browse: Parcourir
               label_branch: Branche
               label_tag: Tag
               label_revision: Révision
               label_revision_plural: Révisions
               label_revision_id: "Révision %{value}"
               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_view_all_revisions: Voir toutes 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 Atom
               label_changes_details: Détails de tous les changements
               label_issue_tracking: Suivi des demandes
               label_spent_time: Temps passé
               label_overall_spent_time: Temps passé global
               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_diff: diff
               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_copied_to: Copié vers
               label_copied_from: Copié depuis
               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_board_locked: Verrouillé
               label_board_sticky: Sticky
               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: Clé d'accès Atom
               label_missing_feeds_access_key: Clé d'accès Atom manquante
               label_feeds_access_key_created_on: "Clé d'accès Atom 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_bulk_edit_selected_time_entries: Modifier les temps passés sélectionnés
               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_option_none: Aucune notification
               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_only_owner: Seulement pour ce que j'ai créé
               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: Groupe
               label_group_plural: Groupes
               label_group_new: Nouveau groupe
               label_group_anonymous: Utilisateurs anonymes
               label_group_non_member: Utilisateurs non membres
               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_update_issue_done_ratios: Mettre à jour l'avancement des demandes
               label_copy_source: Source
               label_copy_target: Cible
               label_copy_same_as_target: Comme la cible
               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_missing_api_access_key: Clé d'accès API manquante
               label_api_access_key_created_on: Clé d'accès API créée il y a %{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_public: Toutes les demandes non privées
               label_issues_visibility_own: Demandes créées par ou assignées à l'utilisateur
               label_git_report_last_commit: Afficher le dernier commit des fichiers et répertoires
               label_parent_revision: Parent
               label_child_revision: Enfant
               label_export_options: Options d'exportation %{export_format}
               label_copy_attachments: Copier les fichiers
               label_copy_subtasks: Copier les sous-tâches
               label_item_position: "%{position} sur %{count}"
               label_completed_versions: Versions passées
               label_search_for_watchers: Rechercher des observateurs
               label_session_expiration: Expiration des sessions
               label_show_closed_projects: Voir les projets fermés
               label_status_transitions: Changements de statut
               label_fields_permissions: Permissions sur les champs
               label_readonly: Lecture
               label_required: Obligatoire
               label_hidden: Caché
               label_attribute_of_project: "%{name} du projet"
               label_attribute_of_issue: "%{name} de la demande"
               label_attribute_of_author: "%{name} de l'auteur"
               label_attribute_of_assigned_to: "%{name} de l'assigné"
               label_attribute_of_user: "%{name} de l'utilisateur"
               label_attribute_of_fixed_version: "%{name} de la version cible"
               label_cross_project_descendants: Avec les sous-projets
               label_cross_project_tree: Avec tout l'arbre
               label_cross_project_hierarchy: Avec toute la hiérarchie
               label_cross_project_system: Avec tous les projets
               label_gantt_progress_line: Ligne de progression
               label_visibility_private: par moi uniquement
               label_visibility_roles: par ces rôles uniquement
               label_visibility_public: par tout le monde
               label_link: Lien
               label_only: seulement
               label_drop_down_list: liste déroulante
               label_checkboxes: cases à cocher
               label_radio_buttons: boutons radio
               label_link_values_to: Lier les valeurs vers l'URL
               label_custom_field_select_type: Selectionner le type d'objet auquel attacher le champ personnalisé
               label_check_for_updates: Vérifier les mises à jour
               label_latest_compatible_version: Dernière version compatible
               label_unknown_plugin: Plugin inconnu
               label_add_projects: Ajouter des projets
               label_users_visibility_all: Tous les utilisateurs actifs
               label_users_visibility_members_of_visible_projects: Membres des projets visibles
               label_edit_attachments: Modifier les fichiers attachés
               label_link_copied_issue: Lier la demande copiée
               label_ask: Demander
               label_search_attachments_yes: Rechercher les noms et descriptions de fichiers
               label_search_attachments_no: Ne pas rechercher les fichiers
               label_search_attachments_only: Rechercher les fichiers uniquement
               label_search_open_issues_only: Demandes ouvertes uniquement
               label_email_address_plural: Emails
               label_email_address_add: Ajouter une adresse email
               label_enable_notifications: Activer les notifications
               label_disable_notifications: Désactiver les notifications
               label_blank_value: non renseigné
               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_edit_associated_wikipage: "Modifier la page wiki associée: %{page_title}"
               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
               button_hide: Cacher
               button_edit_section: Modifier cette section
               button_export: Exporter
               button_delete_my_account: Supprimer mon compte
               button_close: Fermer
               button_reopen: Réouvrir
               status_active: actif
               status_registered: enregistré
               status_locked: verrouillé
               project_status_active: actif
               project_status_closed: fermé
               project_status_archived: archivé
               version_status_open: ouvert
               version_status_locked: verrouillé
               version_status_closed: fermé
               field_active: Actif
               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_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é"
               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, tirets et tirets bas sont autorisés, doit commencer par une minuscule.<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 la ou les demandes(s) selectionnée(s) ?'
               text_issues_destroy_descendants_confirmation: "Cela entrainera également la suppression de %{count} sous-tâche(s)."
               text_time_entries_destroy_confirmation: "Etes-vous sûr de vouloir supprimer les temps passés sélectionné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_convert_available: Binaire convert de ImageMagick présent (optionel)
               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_zoom_in: Zoom avant
               text_zoom_out: Zoom arrière
               text_warn_on_leaving_unsaved: "Cette page contient du texte non sauvegardé qui sera perdu si vous quittez la page."
               text_scm_path_encoding_note: "Défaut : UTF-8"
               text_subversion_repository_note: "Exemples (en fonction des protocoles supportés) : file:///, http://, https://, svn://, svn+[tunnelscheme]://"
               text_git_repository_note: "Chemin vers un dépôt vide et local (exemples : /gitrepo, c:\\gitrepo)"
               text_mercurial_repository_note: "Chemin vers un dépôt local (exemples : /hgrepo, c:\\hgrepo)"
               text_scm_command: Commande
               text_scm_command_version: Version
               text_scm_config: Vous pouvez configurer les commandes des SCM dans config/configuration.yml. Redémarrer l'application après modification.
               text_scm_command_not_available: Ce SCM n'est pas disponible. Vérifier les paramètres dans la section administration.
               text_issue_conflict_resolution_overwrite: "Appliquer quand même ma mise à jour (les notes précédentes seront conservées mais des changements pourront être écrasés)"
               text_issue_conflict_resolution_add_notes: "Ajouter mes notes et ignorer mes autres changements"
               text_issue_conflict_resolution_cancel: "Annuler ma mise à jour et réafficher %{link}"
               text_account_destroy_confirmation: "Êtes-vous sûr de vouloir continuer ?\nVotre compte sera définitivement supprimé, sans aucune possibilité de le réactiver."
               text_session_expiration_settings: "Attention : le changement de ces paramètres peut entrainer l'expiration des sessions utilisateurs en cours, y compris la vôtre."
               text_project_closed: Ce projet est fermé et accessible en lecture seule.
               text_turning_multiple_off: "Si vous désactivez les valeurs multiples, les valeurs multiples seront supprimées pour n'en conserver qu'une par objet."
               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)
               enumeration_system_activity: Activité système
               description_filter: Filtre
               description_search: Champ de recherche
               description_choose_project: Projets
               description_project_scope: Périmètre de recherche
               description_notes: Notes
               description_message_content: Contenu du message
               description_query_sort_criteria_attribute: Critère de tri
               description_query_sort_criteria_direction: Ordre de tri
               description_user_mail_notification: Option de notification
               description_available_columns: Colonnes disponibles
               description_selected_columns: Colonnes sélectionnées
               description_all_columns: Toutes les colonnes
               description_issue_category_reassign: Choisir une catégorie
               description_wiki_subpages_reassign: Choisir une nouvelle page parent
               description_date_range_list: Choisir une période prédéfinie
               description_date_range_interval: Choisir une période
               description_date_from: Date de début
               description_date_to: Date de fin
               text_repository_identifier_info: 'Seuls les lettres minuscules (a-z), chiffres, tirets et tirets bas sont autorisés.<br />Un fois sauvegardé, l''identifiant ne pourra plus être modifié.'

config/settings.yml +4 0

             # Redmine - project management software
             # Copyright (C) 2006-2015  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.
             # DO NOT MODIFY THIS FILE !!!
             # Settings can be defined through the application in Admin -> Settings
             app_title:
               default: Redmine
             app_subtitle:
               default: Project management
             welcome_text:
               default:
             login_required:
               default: 0
             self_registration:
               default: '2'
             lost_password:
               default: 1
             unsubscribe:
               default: 1
             password_min_length:
               format: int
               default: 8
+            # Maximum password age in days
+            password_max_age:
+              format: int
+              default: 0
             # Maximum number of additional email addresses per user
             max_additional_emails:
               format: int
               default: 5
             # Maximum lifetime of user sessions in minutes
             session_lifetime:
               format: int
               default: 0
             # User session timeout in minutes
             session_timeout:
               format: int
               default: 0
             attachment_max_size:
               format: int
               default: 5120
             issues_export_limit:
               format: int
               default: 500
             activity_days_default:
               format: int
               default: 30
             per_page_options:
               default: '25,50,100'
             search_results_per_page:
               default: 10
             mail_from:
               default: redmine@example.net
             bcc_recipients:
               default: 1
             plain_text_mail:
               default: 0
             text_formatting:
               default: textile
             cache_formatted_text:
               default: 0
             wiki_compression:
               default: ""
             default_language:
               default: en
             force_default_language_for_anonymous:
               default: 0
             force_default_language_for_loggedin:
               default: 0
             host_name:
               default: localhost:3000
             protocol:
               default: http
             feeds_limit:
               format: int
               default: 15
             gantt_items_limit:
               format: int
               default: 500
             # Maximum size of files that can be displayed
             # inline through the file viewer (in KB)
             file_max_size_displayed:
               format: int
               default: 512
             diff_max_lines_displayed:
               format: int
               default: 1500
             enabled_scm:
               serialized: true
               default:
               - Subversion
               - Darcs
               - Mercurial
               - Cvs
               - Bazaar
               - Git
             autofetch_changesets:
               default: 1
             sys_api_enabled:
               default: 0
             sys_api_key:
               default: ''
             commit_cross_project_ref:
               default: 0
             commit_ref_keywords:
               default: 'refs,references,IssueID'
             commit_update_keywords:
               serialized: true
               default: []
             commit_logtime_enabled:
               default: 0
             commit_logtime_activity_id:
               format: int
               default: 0
             # autologin duration in days
             # 0 means autologin is disabled
             autologin:
               format: int
               default: 0
             # date format
             date_format:
               default: ''
             time_format:
               default: ''
             user_format:
               default: :firstname_lastname
               format: symbol
             cross_project_issue_relations:
               default: 0
             # Enables subtasks to be in other projects
             cross_project_subtasks:
               default: 'tree'
             link_copied_issue:
               default: 'ask'
             issue_group_assignment:
               default: 0
             default_issue_start_date_to_creation_date:
               default: 1
             notified_events:
               serialized: true
               default:
               - issue_added
               - issue_updated
             mail_handler_body_delimiters:
               default: ''
             mail_handler_excluded_filenames:
               default: ''
             mail_handler_api_enabled:
               default: 0
             mail_handler_api_key:
               default:
             issue_list_default_columns:
               serialized: true
               default:
               - tracker
               - status
               - priority
               - subject
               - assigned_to
               - updated_on
             display_subprojects_issues:
               default: 1
             issue_done_ratio:
               default: 'issue_field'
             default_projects_public:
               default: 1
             default_projects_modules:
               serialized: true
               default:
               - issue_tracking
               - time_tracking
               - news
               - documents
               - files
               - wiki
               - repository
               - boards
               - calendar
               - gantt
             default_projects_tracker_ids:
               serialized: true
               default:
             # Role given to a non-admin user who creates a project
             new_project_user_role_id:
               format: int
               default: ''
             sequential_project_identifiers:
               default: 0
             # encodings used to convert repository files content to UTF-8
             # multiple values accepted, comma separated
             repositories_encodings:
               default: ''
             # encoding used to convert commit logs to UTF-8
             commit_logs_encoding:
               default: 'UTF-8'
             repository_log_display_limit:
               format: int
               default: 100
             ui_theme:
               default: ''
             emails_footer:
               default: |-
                 You have received this notification because you have either subscribed to it, or are involved in it.
                 To change your notification preferences, please click here: http://hostname/my/account
             gravatar_enabled:
               default: 0
             openid:
               default: 0
             gravatar_default:
               default: ''
             start_of_week:
               default: ''
             rest_api_enabled:
               default: 0
             jsonp_enabled:
               default: 0
             default_notification_option:
               default: 'only_my_events'
             emails_header:
               default: ''
             thumbnails_enabled:
               default: 0
             thumbnails_size:
               format: int
               default: 100
             non_working_week_days:
               serialized: true
               default:
               - '6'
               - '7'

test/integration/account_test.rb +34 0

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 AccountTest < Redmine::IntegrationTest
               fixtures :users, :email_addresses, :roles
               def test_login
                 get "/my/page"
                 assert_redirected_to "/login?back_url=http%3A%2F%2Fwww.example.com%2Fmy%2Fpage"
                 log_user('jsmith', 'jsmith')
                 get "/my/account"
                 assert_response :success
                 assert_template "my/account"
               end
               def test_autologin
                 user = User.find(1)
                 Setting.autologin = "7"
                 Token.delete_all
                 # User logs in with 'autologin' checked
                 post '/login', :username => user.login, :password => 'admin', :autologin => 1
                 assert_redirected_to '/my/page'
                 token = Token.first
                 assert_not_nil token
                 assert_equal user, token.user
                 assert_equal 'autologin', token.action
                 assert_equal user.id, session[:user_id]
                 assert_equal token.value, cookies['autologin']
                 # Session is cleared
                 reset!
                 User.current = nil
                 # Clears user's last login timestamp
                 user.update_attribute :last_login_on, nil
                 assert_nil user.reload.last_login_on
                 # User comes back with user's autologin cookie
                 cookies[:autologin] = token.value
                 get '/my/page'
                 assert_response :success
                 assert_template 'my/page'
                 assert_equal user.id, session[:user_id]
                 assert_not_nil user.reload.last_login_on
               end
               def test_autologin_should_use_autologin_cookie_name
                 Token.delete_all
                 Redmine::Configuration.stubs(:[]).with('autologin_cookie_name').returns('custom_autologin')
                 Redmine::Configuration.stubs(:[]).with('autologin_cookie_path').returns('/')
                 Redmine::Configuration.stubs(:[]).with('autologin_cookie_secure').returns(false)
                 with_settings :autologin => '7' do
                   assert_difference 'Token.count' do
                     post '/login', :username => 'admin', :password => 'admin', :autologin => 1
                   end
                   assert_response 302
                   assert cookies['custom_autologin'].present?
                   token = cookies['custom_autologin']
                   # Session is cleared
                   reset!
                   cookies['custom_autologin'] = token
                   get '/my/page'
                   assert_response :success
                   assert_difference 'Token.count', -1 do
                     post '/logout'
                   end
                   assert cookies['custom_autologin'].blank?
                 end
               end
               def test_lost_password
                 Token.delete_all
                 get "/account/lost_password"
                 assert_response :success
                 assert_template "account/lost_password"
                 assert_select 'input[name=mail]'
                 post "/account/lost_password", :mail => 'jSmith@somenet.foo'
                 assert_redirected_to "/login"
                 token = Token.first
                 assert_equal 'recovery', token.action
                 assert_equal 'jsmith@somenet.foo', token.user.mail
                 assert !token.expired?
                 get "/account/lost_password", :token => token.value
                 assert_response :success
                 assert_template "account/password_recovery"
                 assert_select 'input[type=hidden][name=token][value=?]', token.value
                 assert_select 'input[name=new_password]'
                 assert_select 'input[name=new_password_confirmation]'
                 post "/account/lost_password",
                      :token => token.value, :new_password => 'newpass123',
                      :new_password_confirmation => 'newpass123'
                 assert_redirected_to "/login"
                 assert_equal 'Password was successfully updated.', flash[:notice]
                 log_user('jsmith', 'newpass123')
                 assert_equal 0, Token.count
               end
               def test_user_with_must_change_passwd_should_be_forced_to_change_its_password
                 User.find_by_login('jsmith').update_attribute :must_change_passwd, true
                 post '/login', :username => 'jsmith', :password => 'jsmith'
                 assert_redirected_to '/my/page'
                 follow_redirect!
                 assert_redirected_to '/my/password'
                 get '/issues'
                 assert_redirected_to '/my/password'
               end
               def test_user_with_must_change_passwd_should_be_able_to_change_its_password
                 User.find_by_login('jsmith').update_attribute :must_change_passwd, true
                 post '/login', :username => 'jsmith', :password => 'jsmith'
                 assert_redirected_to '/my/page'
                 follow_redirect!
                 assert_redirected_to '/my/password'
                 follow_redirect!
                 assert_response :success
                 post '/my/password', :password => 'jsmith', :new_password => 'newpassword', :new_password_confirmation => 'newpassword'
                 assert_redirected_to '/my/account'
                 follow_redirect!
                 assert_response :success
                 assert_equal false, User.find_by_login('jsmith').must_change_passwd?
               end
+              def test_user_with_expired_password_should_be_forced_to_change_its_password
+                User.find_by_login('jsmith').update_attribute :passwd_changed_on, 14.days.ago
+                with_settings :password_max_age => 7 do
+                  post '/login', :username => 'jsmith', :password => 'jsmith'
+                  assert_redirected_to '/my/page'
+                  follow_redirect!
+                  assert_redirected_to '/my/password'
+                  get '/issues'
+                  assert_redirected_to '/my/password'
+                end
+              end
+              def test_user_with_expired_password_should_be_able_to_change_its_password
+                User.find_by_login('jsmith').update_attribute :passwd_changed_on, 14.days.ago
+                with_settings :password_max_age => 7 do
+                  post '/login', :username => 'jsmith', :password => 'jsmith'
+                  assert_redirected_to '/my/page'
+                  follow_redirect!
+                  assert_redirected_to '/my/password'
+                  follow_redirect!
+                  assert_response :success
+                  post '/my/password', :password => 'jsmith', :new_password => 'newpassword', :new_password_confirmation => 'newpassword'
+                  assert_redirected_to '/my/account'
+                  follow_redirect!
+                  assert_response :success
+                  assert_equal false, User.find_by_login('jsmith').must_change_passwd?
+                end
+              end
               def test_register_with_automatic_activation
                 Setting.self_registration = '3'
                 get '/account/register'
                 assert_response :success
                 assert_template 'account/register'
                 post '/account/register',
                      :user => {:login => "newuser", :language => "en",
                                :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/my/account'
                 follow_redirect!
                 assert_response :success
                 assert_template 'my/account'
                 user = User.find_by_login('newuser')
                 assert_not_nil user
                 assert user.active?
                 assert_not_nil user.last_login_on
               end
               def test_register_with_manual_activation
                 Setting.self_registration = '2'
                 post '/account/register',
                      :user => {:login => "newuser", :language => "en",
                                :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/login'
                 assert !User.find_by_login('newuser').active?
               end
               def test_register_with_email_activation
                 Setting.self_registration = '1'
                 Token.delete_all
                 post '/account/register',
                      :user => {:login => "newuser", :language => "en",
                                :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/login'
                 assert !User.find_by_login('newuser').active?
                 token = Token.first
                 assert_equal 'register', token.action
                 assert_equal 'newuser@foo.bar', token.user.mail
                 assert !token.expired?
                 get '/account/activate', :token => token.value
                 assert_redirected_to '/login'
                 log_user('newuser', 'newpass123')
               end
               def test_onthefly_registration
                 # disable registration
                 Setting.self_registration = '0'
                 AuthSource.expects(:authenticate).returns(
                   {:login => 'foo', :firstname => 'Foo', :lastname => 'Smith',
                    :mail => 'foo@bar.com', :auth_source_id => 66})
                 post '/login', :username => 'foo', :password => 'bar'
                 assert_redirected_to '/my/page'
                 user = User.find_by_login('foo')
                 assert user.is_a?(User)
                 assert_equal 66, user.auth_source_id
                 assert user.hashed_password.blank?
               end
               def test_onthefly_registration_with_invalid_attributes
                 # disable registration
                 Setting.self_registration = '0'
                 AuthSource.expects(:authenticate).returns(
                   {:login => 'foo', :lastname => 'Smith', :auth_source_id => 66})
                 post '/login', :username => 'foo', :password => 'bar'
                 assert_response :success
                 assert_template 'account/register'
                 assert_select 'input[name=?][value=""]', 'user[firstname]'
                 assert_select 'input[name=?][value=Smith]', 'user[lastname]'
                 assert_select 'input[name=?]', 'user[login]', 0
                 assert_select 'input[name=?]', 'user[password]', 0
                 post '/account/register',
                      :user => {:firstname => 'Foo', :lastname => 'Smith', :mail => 'foo@bar.com'}
                 assert_redirected_to '/my/account'
                 user = User.find_by_login('foo')
                 assert user.is_a?(User)
                 assert_equal 66, user.auth_source_id
                 assert user.hashed_password.blank?
               end
               def test_registered_user_should_be_able_to_get_a_new_activation_email
                 Token.delete_all
                 with_settings :self_registration => '1', :default_language => 'en' do
                   # register a new account
                   assert_difference 'User.count' do
                     assert_difference 'Token.count' do
                       post '/account/register',
                          :user => {:login => "newuser", :language => "en",
                                    :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                    :password => "newpass123", :password_confirmation => "newpass123"}
                     end
                   end
                   user = User.order('id desc').first
                   assert_equal User::STATUS_REGISTERED, user.status
                   reset!
                   # try to use "lost password"
                   assert_no_difference 'ActionMailer::Base.deliveries.size' do
                     post '/account/lost_password', :mail => 'newuser@foo.bar'
                   end
                   assert_redirected_to '/account/lost_password'
                   follow_redirect!
                   assert_response :success
                   assert_select 'div.flash', :text => /new activation email/
                   assert_select 'div.flash a[href="/account/activation_email"]'
                   # request a new action activation email
                   assert_difference 'ActionMailer::Base.deliveries.size' do
                     get '/account/activation_email'
                   end
                   assert_redirected_to '/login'
                   token = Token.order('id desc').first
                   activation_path = "/account/activate?token=#{token.value}"
                   assert_include activation_path, mail_body(ActionMailer::Base.deliveries.last)
                   # activate the account
                   get activation_path
                   assert_redirected_to '/login'
                   post '/login', :username => 'newuser', :password => 'newpass123'
                   assert_redirected_to '/my/page'
                 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