jro_apps/redmine Commit - r15293:57afa5345eea

Don't pass conditions to #delete_all....

Jean-Philippe Lang -

r15293:57afa5345eea

parent child

Context file:

r15293:57afa5345eea

Collapse all files

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

app/controllers/application_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require 'uri'
              require 'cgi'
              class Unauthorized < Exception; end
              class ApplicationController < ActionController::Base
                include Redmine::I18n
                include Redmine::Pagination
                include Redmine::Hook::Helper
                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_action :session_expiration, :user_setup, :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
                include Redmine::SudoMode::Controller
                def session_expiration
                  if session[:user_id] && Rails.application.config.redmine_verify_sessions != false
                    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
                    end
                  end
                end
                def session_expired?
                  ! User.verify_session_token(session[:user_id], session[:tk])
                end
                def start_user_session(user)
                  session[:user_id] = user.id
                  session[:tk] = user.generate_session_token
                  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
                  # store current ip address in user object ephemerally
                  user.remote_ip = request.remote_ip if user
                  user
                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'])
-                   Token.delete_all(["user_id = ? AND action = ? AND value = ?", User.current.id, 'session', session[:tk]])
+                   Token.where(["user_id = ? AND action = ?", User.current.id, 'autologin']).delete_all
+                   Token.where(["user_id = ? AND action = ? AND value = ?", User.current.id, 'session', session[:tk]]).delete_all
                    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 = request.original_url
                    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, {:custom_values => :custom_field}).
                    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
                def parse_params_for_bulk_update(params)
                  attributes = (params || {}).reject {|k,v| v.blank?}
                  attributes.keys.each {|k| attributes[k] = '' if attributes[k] == 'none'}
                  if custom = attributes[:custom_field_values]
                    custom.reject! {|k,v| v.blank?}
                    custom.keys.each do |k|
                      if custom[k].is_a?(Array)
                        custom[k] << '' if custom[k].delete('__none__')
                      else
                        custom[k] = '' if custom[k] == '__none__'
                      end
                    end
                  end
                  attributes
                end
                # make sure that the user is a member of the project (or admin) if project is private
                # used as a before_action 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_url = validate_back_url(back_url)
                    redirect_to(valid_url)
                    return
                  elsif options[:referer]
                    redirect_to_referer_or default
                    return
                  end
                  redirect_to default
                  false
                end
                # Returns a validated URL string if back_url is a valid url for redirection,
                # otherwise false
                def validate_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
                  [:scheme, :host, :port].each do |component|
                    if uri.send(component).present? && uri.send(component) != request.send(component)
                      return false
                    end
                    uri.send(:"#{component}=", nil)
                  end
                  # Always ignore basic user:password in the URL
                  uri.userinfo = nil
                  path = uri.to_s
                  # Ensure that the remaining URL starts with a slash, followed by a
                  # non-slash character or the end
                  if path !~ %r{\A/([^/]|\z)}
                    return false
                  end
                  if path.match(%r{/(login|account/register)})
                    return false
                  end
                  if relative_url_root.present? && !path.starts_with?(relative_url_root)
                    return false
                  end
                  return path
                end
                private :validate_back_url
                def valid_back_url?(back_url)
                  !!validate_back_url(back_url)
                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|Edge)} ? 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/issue_status.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class IssueStatus < ActiveRecord::Base
                before_destroy :check_integrity
                has_many :workflows, :class_name => 'WorkflowTransition', :foreign_key => "old_status_id"
                has_many :workflow_transitions_as_new_status, :class_name => 'WorkflowTransition', :foreign_key => "new_status_id"
                acts_as_positioned
                after_update :handle_is_closed_change
                before_destroy :delete_workflow_rules
                validates_presence_of :name
                validates_uniqueness_of :name
                validates_length_of :name, :maximum => 30
                validates_inclusion_of :default_done_ratio, :in => 0..100, :allow_nil => true
                attr_protected :id
                scope :sorted, lambda { order(:position) }
                scope :named, lambda {|arg| where("LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip)}
                # Update all the +Issues+ setting their done_ratio to the value of their +IssueStatus+
                def self.update_issue_done_ratios
                  if Issue.use_status_for_done_ratio?
                    IssueStatus.where("default_done_ratio >= 0").each do |status|
                      Issue.where({:status_id => status.id}).update_all({:done_ratio => status.default_done_ratio})
                    end
                  end
                  return Issue.use_status_for_done_ratio?
                end
                # Returns an array of all statuses the given role can switch to
                def new_statuses_allowed_to(roles, tracker, author=false, assignee=false)
                  self.class.new_statuses_allowed(self, roles, tracker, author, assignee)
                end
                alias :find_new_statuses_allowed_to :new_statuses_allowed_to
                def self.new_statuses_allowed(status, roles, tracker, author=false, assignee=false)
                  if roles.present? && tracker
                    status_id = status.try(:id) || 0
                    scope = IssueStatus.
                      joins(:workflow_transitions_as_new_status).
                      where(:workflows => {:old_status_id => status_id, :role_id => roles.map(&:id), :tracker_id => tracker.id})
                    unless author && assignee
                      if author || assignee
                        scope = scope.where("author = ? OR assignee = ?", author, assignee)
                      else
                        scope = scope.where("author = ? AND assignee = ?", false, false)
                      end
                    end
                    scope.distinct.to_a.sort
                  else
                    []
                  end
                end
                def <=>(status)
                  position <=> status.position
                end
                def to_s; name end
                private
                # Updates issues closed_on attribute when an existing status is set as closed.
                def handle_is_closed_change
                  if is_closed_changed? && is_closed == true
                    # First we update issues that have a journal for when the current status was set,
                    # a subselect is used to update all issues with a single query
                    subselect = "SELECT MAX(j.created_on) FROM #{Journal.table_name} j" +
                      " JOIN #{JournalDetail.table_name} d ON d.journal_id = j.id" +
                      " WHERE j.journalized_type = 'Issue' AND j.journalized_id = #{Issue.table_name}.id" +
                      " AND d.property = 'attr' AND d.prop_key = 'status_id' AND d.value = :status_id"
                    Issue.where(:status_id => id, :closed_on => nil).
                      update_all(["closed_on = (#{subselect})", {:status_id => id.to_s}])
                    # Then we update issues that don't have a journal which means the
                    # current status was set on creation
                    Issue.where(:status_id => id, :closed_on => nil).update_all("closed_on = created_on")
                  end
                end
                def check_integrity
                  if Issue.where(:status_id => id).any?
                    raise "This status is used by some issues"
                  elsif Tracker.where(:default_status_id => id).any?
                    raise "This status is used as the default status by some trackers"
                  end
                end
                # Deletes associated workflows
                def delete_workflow_rules
-                 WorkflowRule.delete_all(["old_status_id = :id OR new_status_id = :id", {:id => id}])
+                 WorkflowRule.where(["old_status_id = :id OR new_status_id = :id", {:id => id}]).delete_all
                end
              end

app/models/project.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class Project < ActiveRecord::Base
                include Redmine::SafeAttributes
                include Redmine::NestedSet::ProjectNestedSet
                # Project statuses
                STATUS_ACTIVE     = 1
                STATUS_CLOSED     = 5
                STATUS_ARCHIVED   = 9
                # Maximum length for project identifiers
                IDENTIFIER_MAX_LENGTH = 100
                # Specific overridden Activities
                has_many :time_entry_activities
                has_many :memberships, :class_name => 'Member', :inverse_of => :project
                # Memberships of active users only
                has_many :members,
                         lambda { joins(:principal).where(:users => {:type => 'User', :status => Principal::STATUS_ACTIVE}) }
                has_many :enabled_modules, :dependent => :delete_all
                has_and_belongs_to_many :trackers, lambda {order(:position)}
                has_many :issues, :dependent => :destroy
                has_many :issue_changes, :through => :issues, :source => :journals
                has_many :versions, lambda {order("#{Version.table_name}.effective_date DESC, #{Version.table_name}.name DESC")}, :dependent => :destroy
                belongs_to :default_version, :class_name => 'Version'
                has_many :time_entries, :dependent => :destroy
                has_many :queries, :class_name => 'IssueQuery', :dependent => :delete_all
                has_many :documents, :dependent => :destroy
                has_many :news, lambda {includes(:author)}, :dependent => :destroy
                has_many :issue_categories, lambda {order("#{IssueCategory.table_name}.name")}, :dependent => :delete_all
                has_many :boards, lambda {order("position ASC")}, :dependent => :destroy
                has_one :repository, lambda {where(["is_default = ?", true])}
                has_many :repositories, :dependent => :destroy
                has_many :changesets, :through => :repository
                has_one :wiki, :dependent => :destroy
                # Custom field for the project issues
                has_and_belongs_to_many :issue_custom_fields,
                                        lambda {order("#{CustomField.table_name}.position")},
                                        :class_name => 'IssueCustomField',
                                        :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}",
                                        :association_foreign_key => 'custom_field_id'
                acts_as_attachable :view_permission => :view_files,
                                   :edit_permission => :manage_files,
                                   :delete_permission => :manage_files
                acts_as_customizable
                acts_as_searchable :columns => ['name', 'identifier', 'description'], :project_key => "#{Project.table_name}.id", :permission => nil
                acts_as_event :title => Proc.new {|o| "#{l(:label_project)}: #{o.name}"},
                              :url => Proc.new {|o| {:controller => 'projects', :action => 'show', :id => o}},
                              :author => nil
                attr_protected :status
                validates_presence_of :name, :identifier
                validates_uniqueness_of :identifier, :if => Proc.new {|p| p.identifier_changed?}
                validates_length_of :name, :maximum => 255
                validates_length_of :homepage, :maximum => 255
                validates_length_of :identifier, :in => 1..IDENTIFIER_MAX_LENGTH
                # downcase letters, digits, dashes but not digits only
                validates_format_of :identifier, :with => /\A(?!\d+$)[a-z0-9\-_]*\z/, :if => Proc.new { |p| p.identifier_changed? }
                # reserved words
                validates_exclusion_of :identifier, :in => %w( new )
                validate :validate_parent
                after_save :update_inherited_members, :if => Proc.new {|project| project.inherit_members_changed?}
                after_save :remove_inherited_member_roles, :add_inherited_member_roles, :if => Proc.new {|project| project.parent_id_changed?}
                after_update :update_versions_from_hierarchy_change, :if => Proc.new {|project| project.parent_id_changed?}
                before_destroy :delete_all_members
                scope :has_module, lambda {|mod|
                  where("#{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name=?)", mod.to_s)
                }
                scope :active, lambda { where(:status => STATUS_ACTIVE) }
                scope :status, lambda {|arg| where(arg.blank? ? nil : {:status => arg.to_i}) }
                scope :all_public, lambda { where(:is_public => true) }
                scope :visible, lambda {|*args| where(Project.visible_condition(args.shift || User.current, *args)) }
                scope :allowed_to, lambda {|*args|
                  user = User.current
                  permission = nil
                  if args.first.is_a?(Symbol)
                    permission = args.shift
                  else
                    user = args.shift
                    permission = args.shift
                  end
                  where(Project.allowed_to_condition(user, permission, *args))
                }
                scope :like, lambda {|arg|
                  if arg.blank?
                    where(nil)
                  else
                    pattern = "%#{arg.to_s.strip.downcase}%"
                    where("LOWER(identifier) LIKE :p OR LOWER(name) LIKE :p", :p => pattern)
                  end
                }
                scope :sorted, lambda {order(:lft)}
                scope :having_trackers, lambda {
                  where("#{Project.table_name}.id IN (SELECT DISTINCT project_id FROM #{table_name_prefix}projects_trackers#{table_name_suffix})")
                }
                def initialize(attributes=nil, *args)
                  super
                  initialized = (attributes || {}).stringify_keys
                  if !initialized.key?('identifier') && Setting.sequential_project_identifiers?
                    self.identifier = Project.next_identifier
                  end
                  if !initialized.key?('is_public')
                    self.is_public = Setting.default_projects_public?
                  end
                  if !initialized.key?('enabled_module_names')
                    self.enabled_module_names = Setting.default_projects_modules
                  end
                  if !initialized.key?('trackers') && !initialized.key?('tracker_ids')
                    default = Setting.default_projects_tracker_ids
                    if default.is_a?(Array)
                      self.trackers = Tracker.where(:id => default.map(&:to_i)).sorted.to_a
                    else
                      self.trackers = Tracker.sorted.to_a
                    end
                  end
                end
                def identifier=(identifier)
                  super unless identifier_frozen?
                end
                def identifier_frozen?
                  errors[:identifier].blank? && !(new_record? || identifier.blank?)
                end
                # returns latest created projects
                # non public projects will be returned only if user is a member of those
                def self.latest(user=nil, count=5)
                  visible(user).limit(count).
                    order(:created_on => :desc).
                    where("#{table_name}.created_on >= ?", 30.days.ago).
                    to_a
                end
                # Returns true if the project is visible to +user+ or to the current user.
                def visible?(user=User.current)
                  user.allowed_to?(:view_project, self)
                end
                # Returns a SQL conditions string used to find all projects visible by the specified user.
                #
                # Examples:
                #   Project.visible_condition(admin)        => "projects.status = 1"
                #   Project.visible_condition(normal_user)  => "((projects.status = 1) AND (projects.is_public = 1 OR projects.id IN (1,3,4)))"
                #   Project.visible_condition(anonymous)    => "((projects.status = 1) AND (projects.is_public = 1))"
                def self.visible_condition(user, options={})
                  allowed_to_condition(user, :view_project, options)
                end
                # Returns a SQL conditions string used to find all projects for which +user+ has the given +permission+
                #
                # Valid options:
                # * :project => limit the condition to project
                # * :with_subprojects => limit the condition to project and its subprojects
                # * :member => limit the condition to the user projects
                def self.allowed_to_condition(user, permission, options={})
                  perm = Redmine::AccessControl.permission(permission)
                  base_statement = (perm && perm.read? ? "#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED}" : "#{Project.table_name}.status = #{Project::STATUS_ACTIVE}")
                  if perm && perm.project_module
                    # If the permission belongs to a project module, make sure the module is enabled
                    base_statement << " AND #{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name='#{perm.project_module}')"
                  end
                  if project = options[:project]
                    project_statement = project.project_condition(options[:with_subprojects])
                    base_statement = "(#{project_statement}) AND (#{base_statement})"
                  end
                  if user.admin?
                    base_statement
                  else
                    statement_by_role = {}
                    unless options[:member]
                      role = user.builtin_role
                      if role.allowed_to?(permission)
                        s = "#{Project.table_name}.is_public = #{connection.quoted_true}"
                        if user.id
                          s = "(#{s} AND #{Project.table_name}.id NOT IN (SELECT project_id FROM #{Member.table_name} WHERE user_id = #{user.id}))"
                        end
                        statement_by_role[role] = s
                      end
                    end
                    user.projects_by_role.each do |role, projects|
                      if role.allowed_to?(permission) && projects.any?
                        statement_by_role[role] = "#{Project.table_name}.id IN (#{projects.collect(&:id).join(',')})"
                      end
                    end
                    if statement_by_role.empty?
                      "1=0"
                    else
                      if block_given?
                        statement_by_role.each do |role, statement|
                          if s = yield(role, user)
                            statement_by_role[role] = "(#{statement} AND (#{s}))"
                          end
                        end
                      end
                      "((#{base_statement}) AND (#{statement_by_role.values.join(' OR ')}))"
                    end
                  end
                end
                def override_roles(role)
                  @override_members ||= memberships.
                    joins(:principal).
                    where(:users => {:type => ['GroupAnonymous', 'GroupNonMember']}).to_a
                  group_class = role.anonymous? ? GroupAnonymous : GroupNonMember
                  member = @override_members.detect {|m| m.principal.is_a? group_class}
                  member ? member.roles.to_a : [role]
                end
                def principals
                  @principals ||= Principal.active.joins(:members).where("#{Member.table_name}.project_id = ?", id).distinct
                end
                def users
                  @users ||= User.active.joins(:members).where("#{Member.table_name}.project_id = ?", id).distinct
                end
                # Returns the Systemwide and project specific activities
                def activities(include_inactive=false)
                  t = TimeEntryActivity.table_name
                  scope = TimeEntryActivity.where("#{t}.project_id IS NULL OR #{t}.project_id = ?", id)
                  overridden_activity_ids = self.time_entry_activities.pluck(:parent_id).compact
                  if overridden_activity_ids.any?
                    scope = scope.where("#{t}.id NOT IN (?)", overridden_activity_ids)
                  end
                  unless include_inactive
                    scope = scope.active
                  end
                  scope
                end
                # Will create a new Project specific Activity or update an existing one
                #
                # This will raise a ActiveRecord::Rollback if the TimeEntryActivity
                # does not successfully save.
                def update_or_create_time_entry_activity(id, activity_hash)
                  if activity_hash.respond_to?(:has_key?) && activity_hash.has_key?('parent_id')
                    self.create_time_entry_activity_if_needed(activity_hash)
                  else
                    activity = project.time_entry_activities.find_by_id(id.to_i)
                    activity.update_attributes(activity_hash) if activity
                  end
                end
                # Create a new TimeEntryActivity if it overrides a system TimeEntryActivity
                #
                # This will raise a ActiveRecord::Rollback if the TimeEntryActivity
                # does not successfully save.
                def create_time_entry_activity_if_needed(activity)
                  if activity['parent_id']
                    parent_activity = TimeEntryActivity.find(activity['parent_id'])
                    activity['name'] = parent_activity.name
                    activity['position'] = parent_activity.position
                    if Enumeration.overriding_change?(activity, parent_activity)
                      project_activity = self.time_entry_activities.create(activity)
                      if project_activity.new_record?
                        raise ActiveRecord::Rollback, "Overriding TimeEntryActivity was not successfully saved"
                      else
                        self.time_entries.
                          where(:activity_id => parent_activity.id).
                          update_all(:activity_id => project_activity.id)
                      end
                    end
                  end
                end
                # Returns a :conditions SQL string that can be used to find the issues associated with this project.
                #
                # Examples:
                #   project.project_condition(true)  => "(projects.id = 1 OR (projects.lft > 1 AND projects.rgt < 10))"
                #   project.project_condition(false) => "projects.id = 1"
                def project_condition(with_subprojects)
                  cond = "#{Project.table_name}.id = #{id}"
                  cond = "(#{cond} OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt}))" if with_subprojects
                  cond
                end
                def self.find(*args)
                  if args.first && args.first.is_a?(String) && !args.first.match(/^\d*$/)
                    project = find_by_identifier(*args)
                    raise ActiveRecord::RecordNotFound, "Couldn't find Project with identifier=#{args.first}" if project.nil?
                    project
                  else
                    super
                  end
                end
                def self.find_by_param(*args)
                  self.find(*args)
                end
                alias :base_reload :reload
                def reload(*args)
                  @principals = nil
                  @users = nil
                  @shared_versions = nil
                  @rolled_up_versions = nil
                  @rolled_up_trackers = nil
                  @all_issue_custom_fields = nil
                  @all_time_entry_custom_fields = nil
                  @to_param = nil
                  @allowed_parents = nil
                  @allowed_permissions = nil
                  @actions_allowed = nil
                  @start_date = nil
                  @due_date = nil
                  @override_members = nil
                  @assignable_users = nil
                  base_reload(*args)
                end
                def to_param
                  if new_record?
                    nil
                  else
                    # id is used for projects with a numeric identifier (compatibility)
                    @to_param ||= (identifier.to_s =~ %r{^\d*$} ? id.to_s : identifier)
                  end
                end
                def active?
                  self.status == STATUS_ACTIVE
                end
                def archived?
                  self.status == STATUS_ARCHIVED
                end
                # Archives the project and its descendants
                def archive
                  # Check that there is no issue of a non descendant project that is assigned
                  # to one of the project or descendant versions
                  version_ids = self_and_descendants.joins(:versions).pluck("#{Version.table_name}.id")
                  if version_ids.any? &&
                    Issue.
                      includes(:project).
                      where("#{Project.table_name}.lft < ? OR #{Project.table_name}.rgt > ?", lft, rgt).
                      where(:fixed_version_id => version_ids).
                      exists?
                    return false
                  end
                  Project.transaction do
                    archive!
                  end
                  true
                end
                # Unarchives the project
                # All its ancestors must be active
                def unarchive
                  return false if ancestors.detect {|a| !a.active?}
                  update_attribute :status, STATUS_ACTIVE
                end
                def close
                  self_and_descendants.status(STATUS_ACTIVE).update_all :status => STATUS_CLOSED
                end
                def reopen
                  self_and_descendants.status(STATUS_CLOSED).update_all :status => STATUS_ACTIVE
                end
                # Returns an array of projects the project can be moved to
                # by the current user
                def allowed_parents(user=User.current)
                  return @allowed_parents if @allowed_parents
                  @allowed_parents = Project.allowed_to(user, :add_subprojects).to_a
                  @allowed_parents = @allowed_parents - self_and_descendants
                  if user.allowed_to?(:add_project, nil, :global => true) || (!new_record? && parent.nil?)
                    @allowed_parents << nil
                  end
                  unless parent.nil? || @allowed_parents.empty? || @allowed_parents.include?(parent)
                    @allowed_parents << parent
                  end
                  @allowed_parents
                end
                # Sets the parent of the project with authorization check
                def set_allowed_parent!(p)
                  ActiveSupport::Deprecation.warn "Project#set_allowed_parent! is deprecated and will be removed in Redmine 4, use #safe_attributes= instead."
                  p = p.id if p.is_a?(Project)
                  send :safe_attributes, {:project_id => p}
                  save
                end
                # Sets the parent of the project and saves the project
                # Argument can be either a Project, a String, a Fixnum or nil
                def set_parent!(p)
                  if p.is_a?(Project)
                    self.parent = p
                  else
                    self.parent_id = p
                  end
                  save
                end
                # Returns a scope of the trackers used by the project and its active sub projects
                def rolled_up_trackers(include_subprojects=true)
                  if include_subprojects
                    @rolled_up_trackers ||= rolled_up_trackers_base_scope.
                        where("#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ?", lft, rgt)
                  else
                    rolled_up_trackers_base_scope.
                      where(:projects => {:id => id})
                  end
                end
                def rolled_up_trackers_base_scope
                  Tracker.
                    joins(projects: :enabled_modules).
                    where("#{Project.table_name}.status <> ?", STATUS_ARCHIVED).
                    where(:enabled_modules => {:name => 'issue_tracking'}).
                    distinct.
                    sorted
                end
                # Closes open and locked project versions that are completed
                def close_completed_versions
                  Version.transaction do
                    versions.where(:status => %w(open locked)).each do |version|
                      if version.completed?
                        version.update_attribute(:status, 'closed')
                      end
                    end
                  end
                end
                # Returns a scope of the Versions on subprojects
                def rolled_up_versions
                  @rolled_up_versions ||=
                    Version.
                      joins(:project).
                      where("#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ? AND #{Project.table_name}.status <> ?", lft, rgt, STATUS_ARCHIVED)
                end
                # Returns a scope of the Versions used by the project
                def shared_versions
                  if new_record?
                    Version.
                      joins(:project).
                      preload(:project).
                      where("#{Project.table_name}.status <> ? AND #{Version.table_name}.sharing = 'system'", STATUS_ARCHIVED)
                  else
                    @shared_versions ||= begin
                      r = root? ? self : root
                      Version.
                        joins(:project).
                        preload(:project).
                        where("#{Project.table_name}.id = #{id}" +
                                " OR (#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED} AND (" +
                                  " #{Version.table_name}.sharing = 'system'" +
                                  " OR (#{Project.table_name}.lft >= #{r.lft} AND #{Project.table_name}.rgt <= #{r.rgt} AND #{Version.table_name}.sharing = 'tree')" +
                                  " OR (#{Project.table_name}.lft < #{lft} AND #{Project.table_name}.rgt > #{rgt} AND #{Version.table_name}.sharing IN ('hierarchy', 'descendants'))" +
                                  " OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt} AND #{Version.table_name}.sharing = 'hierarchy')" +
                                "))")
                    end
                  end
                end
                # Returns a hash of project users grouped by role
                def users_by_role
                  members.includes(:user, :roles).inject({}) do |h, m|
                    m.roles.each do |r|
                      h[r] ||= []
                      h[r] << m.user
                    end
                    h
                  end
                end
                # Adds user as a project member with the default role
                # Used for when a non-admin user creates a project
                def add_default_member(user)
                  role = Role.givable.find_by_id(Setting.new_project_user_role_id.to_i) || Role.givable.first
                  member = Member.new(:project => self, :principal => user, :roles => [role])
                  self.members << member
                  member
                end
                # Deletes all project's members
                def delete_all_members
                  me, mr = Member.table_name, MemberRole.table_name
                  self.class.connection.delete("DELETE FROM #{mr} WHERE #{mr}.member_id IN (SELECT #{me}.id FROM #{me} WHERE #{me}.project_id = #{id})")
-                 Member.delete_all(['project_id = ?', id])
+                 Member.where(:project_id => id).delete_all
                end
                # Return a Principal scope of users/groups issues can be assigned to
                def assignable_users(tracker=nil)
                  return @assignable_users[tracker] if @assignable_users && @assignable_users[tracker]
                  types = ['User']
                  types << 'Group' if Setting.issue_group_assignment?
                  scope = Principal.
                    active.
                    joins(:members => :roles).
                    where(:type => types, :members => {:project_id => id}, :roles => {:assignable => true}).
                    distinct.
                    sorted
                  if tracker
                    # Rejects users that cannot the view the tracker
                    roles = Role.where(:assignable => true).select {|role| role.permissions_tracker?(:view_issues, tracker)}
                    scope = scope.where(:roles => {:id => roles.map(&:id)})
                  end
                  @assignable_users ||= {}
                  @assignable_users[tracker] = scope
                end
                # Returns the mail addresses of users that should be always notified on project events
                def recipients
                  notified_users.collect {|user| user.mail}
                end
                # Returns the users that should be notified on project events
                def notified_users
                  # TODO: User part should be extracted to User#notify_about?
                  members.preload(:principal).select {|m| m.principal.present? && (m.mail_notification? || m.principal.mail_notification == 'all')}.collect {|m| m.principal}
                end
                # Returns a scope of all custom fields enabled for project issues
                # (explicitly associated custom fields and custom fields enabled for all projects)
                def all_issue_custom_fields
                  if new_record?
                    @all_issue_custom_fields ||= IssueCustomField.
                      sorted.
                      where("is_for_all = ? OR id IN (?)", true, issue_custom_field_ids)
                  else
                    @all_issue_custom_fields ||= IssueCustomField.
                      sorted.
                      where("is_for_all = ? OR id IN (SELECT DISTINCT cfp.custom_field_id" +
                        " FROM #{table_name_prefix}custom_fields_projects#{table_name_suffix} cfp" +
                        " WHERE cfp.project_id = ?)", true, id)
                  end
                end
                def project
                  self
                end
                def <=>(project)
                  name.casecmp(project.name)
                end
                def to_s
                  name
                end
                # Returns a short description of the projects (first lines)
                def short_description(length = 255)
                  description.gsub(/^(.{#{length}}[^\n\r]*).*$/m, '\1...').strip if description
                end
                def css_classes
                  s = 'project'
                  s << ' root' if root?
                  s << ' child' if child?
                  s << (leaf? ? ' leaf' : ' parent')
                  unless active?
                    if archived?
                      s << ' archived'
                    else
                      s << ' closed'
                    end
                  end
                  s
                end
                # The earliest start date of a project, based on it's issues and versions
                def start_date
                  @start_date ||= [
                   issues.minimum('start_date'),
                   shared_versions.minimum('effective_date'),
                   Issue.fixed_version(shared_versions).minimum('start_date')
                  ].compact.min
                end
                # The latest due date of an issue or version
                def due_date
                  @due_date ||= [
                   issues.maximum('due_date'),
                   shared_versions.maximum('effective_date'),
                   Issue.fixed_version(shared_versions).maximum('due_date')
                  ].compact.max
                end
                def overdue?
                  active? && !due_date.nil? && (due_date < User.current.today)
                end
                # Returns the percent completed for this project, based on the
                # progress on it's versions.
                def completed_percent(options={:include_subprojects => false})
                  if options.delete(:include_subprojects)
                    total = self_and_descendants.collect(&:completed_percent).sum
                    total / self_and_descendants.count
                  else
                    if versions.count > 0
                      total = versions.collect(&:completed_percent).sum
                      total / versions.count
                    else
 
                    end
                  end
                end
                # Return true if this project allows to do the specified action.
                # action can be:
                # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
                # * a permission Symbol (eg. :edit_project)
                def allows_to?(action)
                  if archived?
                    # No action allowed on archived projects
                    return false
                  end
                  unless active? || Redmine::AccessControl.read_action?(action)
                    # No write action allowed on closed projects
                    return false
                  end
                  # No action allowed on disabled modules
                  if action.is_a? Hash
                    allowed_actions.include? "#{action[:controller]}/#{action[:action]}"
                  else
                    allowed_permissions.include? action
                  end
                end
                # Return the enabled module with the given name
                # or nil if the module is not enabled for the project
                def enabled_module(name)
                  name = name.to_s
                  enabled_modules.detect {|m| m.name == name}
                end
                # Return true if the module with the given name is enabled
                def module_enabled?(name)
                  enabled_module(name).present?
                end
                def enabled_module_names=(module_names)
                  if module_names && module_names.is_a?(Array)
                    module_names = module_names.collect(&:to_s).reject(&:blank?)
                    self.enabled_modules = module_names.collect {|name| enabled_modules.detect {|mod| mod.name == name} || EnabledModule.new(:name => name)}
                  else
                    enabled_modules.clear
                  end
                end
                # Returns an array of the enabled modules names
                def enabled_module_names
                  enabled_modules.collect(&:name)
                end
                # Enable a specific module
                #
                # Examples:
                #   project.enable_module!(:issue_tracking)
                #   project.enable_module!("issue_tracking")
                def enable_module!(name)
                  enabled_modules << EnabledModule.new(:name => name.to_s) unless module_enabled?(name)
                end
                # Disable a module if it exists
                #
                # Examples:
                #   project.disable_module!(:issue_tracking)
                #   project.disable_module!("issue_tracking")
                #   project.disable_module!(project.enabled_modules.first)
                def disable_module!(target)
                  target = enabled_modules.detect{|mod| target.to_s == mod.name} unless enabled_modules.include?(target)
                  target.destroy unless target.blank?
                end
                safe_attributes 'name',
                  'description',
                  'homepage',
                  'is_public',
                  'identifier',
                  'custom_field_values',
                  'custom_fields',
                  'tracker_ids',
                  'issue_custom_field_ids',
                  'parent_id',
                  'default_version_id'
                safe_attributes 'enabled_module_names',
                  :if => lambda {|project, user| project.new_record? || user.allowed_to?(:select_project_modules, project) }
                safe_attributes 'inherit_members',
                  :if => lambda {|project, user| project.parent.nil? || project.parent.visible?(user)}
                def safe_attributes=(attrs, user=User.current)
                  return unless attrs.is_a?(Hash)
                  attrs = attrs.deep_dup
                  @unallowed_parent_id = nil
                  if new_record? || attrs.key?('parent_id')
                    parent_id_param = attrs['parent_id'].to_s
                    if new_record? || parent_id_param != parent_id.to_s
                      p = parent_id_param.present? ? Project.find_by_id(parent_id_param) : nil
                      unless allowed_parents(user).include?(p)
                        attrs.delete('parent_id')
                        @unallowed_parent_id = true
                      end
                    end
                  end
                  super(attrs, user)
                end
                # Returns an auto-generated project identifier based on the last identifier used
                def self.next_identifier
                  p = Project.order('id DESC').first
                  p.nil? ? nil : p.identifier.to_s.succ
                end
                # Copies and saves the Project instance based on the +project+.
                # Duplicates the source project's:
                # * Wiki
                # * Versions
                # * Categories
                # * Issues
                # * Members
                # * Queries
                #
                # Accepts an +options+ argument to specify what to copy
                #
                # Examples:
                #   project.copy(1)                                    # => copies everything
                #   project.copy(1, :only => 'members')                # => copies members only
                #   project.copy(1, :only => ['members', 'versions'])  # => copies members and versions
                def copy(project, options={})
                  project = project.is_a?(Project) ? project : Project.find(project)
                  to_be_copied = %w(wiki versions issue_categories issues members queries boards)
                  to_be_copied = to_be_copied & Array.wrap(options[:only]) unless options[:only].nil?
                  Project.transaction do
                    if save
                      reload
                      to_be_copied.each do |name|
                        send "copy_#{name}", project
                      end
                      Redmine::Hook.call_hook(:model_project_copy_before_save, :source_project => project, :destination_project => self)
                      save
                    else
                      false
                    end
                  end
                end
                def member_principals
                  ActiveSupport::Deprecation.warn "Project#member_principals is deprecated and will be removed in Redmine 4.0. Use #memberships.active instead."
                  memberships.active
                end
                # Returns a new unsaved Project instance with attributes copied from +project+
                def self.copy_from(project)
                  project = project.is_a?(Project) ? project : Project.find(project)
                  # clear unique attributes
                  attributes = project.attributes.dup.except('id', 'name', 'identifier', 'status', 'parent_id', 'lft', 'rgt')
                  copy = Project.new(attributes)
                  copy.enabled_module_names = project.enabled_module_names
                  copy.trackers = project.trackers
                  copy.custom_values = project.custom_values.collect {|v| v.clone}
                  copy.issue_custom_fields = project.issue_custom_fields
                  copy
                end
                # Yields the given block for each project with its level in the tree
                def self.project_tree(projects, &block)
                  ancestors = []
                  projects.sort_by(&:lft).each do |project|
                    while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                      ancestors.pop
                    end
                    yield project, ancestors.size
                    ancestors << project
                  end
                end
                private
                def update_inherited_members
                  if parent
                    if inherit_members? && !inherit_members_was
                      remove_inherited_member_roles
                      add_inherited_member_roles
                    elsif !inherit_members? && inherit_members_was
                      remove_inherited_member_roles
                    end
                  end
                end
                def remove_inherited_member_roles
                  member_roles = memberships.map(&:member_roles).flatten
                  member_role_ids = member_roles.map(&:id)
                  member_roles.each do |member_role|
                    if member_role.inherited_from && !member_role_ids.include?(member_role.inherited_from)
                      member_role.destroy
                    end
                  end
                end
                def add_inherited_member_roles
                  if inherit_members? && parent
                    parent.memberships.each do |parent_member|
                      member = Member.find_or_new(self.id, parent_member.user_id)
                      parent_member.member_roles.each do |parent_member_role|
                        member.member_roles << MemberRole.new(:role => parent_member_role.role, :inherited_from => parent_member_role.id)
                      end
                      member.save!
                    end
                    memberships.reset
                  end
                end
                def update_versions_from_hierarchy_change
                  Issue.update_versions_from_hierarchy_change(self)
                end
                def validate_parent
                  if @unallowed_parent_id
                    errors.add(:parent_id, :invalid)
                  elsif parent_id_changed?
                    unless parent.nil? || (parent.active? && move_possible?(parent))
                      errors.add(:parent_id, :invalid)
                    end
                  end
                end
                # Copies wiki from +project+
                def copy_wiki(project)
                  # Check that the source project has a wiki first
                  unless project.wiki.nil?
                    wiki = self.wiki || Wiki.new
                    wiki.attributes = project.wiki.attributes.dup.except("id", "project_id")
                    wiki_pages_map = {}
                    project.wiki.pages.each do |page|
                      # Skip pages without content
                      next if page.content.nil?
                      new_wiki_content = WikiContent.new(page.content.attributes.dup.except("id", "page_id", "updated_on"))
                      new_wiki_page = WikiPage.new(page.attributes.dup.except("id", "wiki_id", "created_on", "parent_id"))
                      new_wiki_page.content = new_wiki_content
                      wiki.pages << new_wiki_page
                      wiki_pages_map[page.id] = new_wiki_page
                    end
                    self.wiki = wiki
                    wiki.save
                    # Reproduce page hierarchy
                    project.wiki.pages.each do |page|
                      if page.parent_id && wiki_pages_map[page.id]
                        wiki_pages_map[page.id].parent = wiki_pages_map[page.parent_id]
                        wiki_pages_map[page.id].save
                      end
                    end
                  end
                end
                # Copies versions from +project+
                def copy_versions(project)
                  project.versions.each do |version|
                    new_version = Version.new
                    new_version.attributes = version.attributes.dup.except("id", "project_id", "created_on", "updated_on")
                    self.versions << new_version
                  end
                end
                # Copies issue categories from +project+
                def copy_issue_categories(project)
                  project.issue_categories.each do |issue_category|
                    new_issue_category = IssueCategory.new
                    new_issue_category.attributes = issue_category.attributes.dup.except("id", "project_id")
                    self.issue_categories << new_issue_category
                  end
                end
                # Copies issues from +project+
                def copy_issues(project)
                  # Stores the source issue id as a key and the copied issues as the
                  # value.  Used to map the two together for issue relations.
                  issues_map = {}
                  # Store status and reopen locked/closed versions
                  version_statuses = versions.reject(&:open?).map {|version| [version, version.status]}
                  version_statuses.each do |version, status|
                    version.update_attribute :status, 'open'
                  end
                  # Get issues sorted by root_id, lft so that parent issues
                  # get copied before their children
                  project.issues.reorder('root_id, lft').each do |issue|
                    new_issue = Issue.new
                    new_issue.copy_from(issue, :subtasks => false, :link => false)
                    new_issue.project = self
                    # Changing project resets the custom field values
                    # TODO: handle this in Issue#project=
                    new_issue.custom_field_values = issue.custom_field_values.inject({}) {|h,v| h[v.custom_field_id] = v.value; h}
                    # Reassign fixed_versions by name, since names are unique per project
                    if issue.fixed_version && issue.fixed_version.project == project
                      new_issue.fixed_version = self.versions.detect {|v| v.name == issue.fixed_version.name}
                    end
                    # Reassign version custom field values
                    new_issue.custom_field_values.each do |custom_value|
                      if custom_value.custom_field.field_format == 'version' && custom_value.value.present?
                        versions = Version.where(:id => custom_value.value).to_a
                        new_value = versions.map do |version|
                          if version.project == project
                            self.versions.detect {|v| v.name == version.name}.try(:id)
                          else
                            version.id
                          end
                        end
                        new_value.compact!
                        new_value = new_value.first unless custom_value.custom_field.multiple?
                        custom_value.value = new_value
                      end
                    end
                    # Reassign the category by name, since names are unique per project
                    if issue.category
                      new_issue.category = self.issue_categories.detect {|c| c.name == issue.category.name}
                    end
                    # Parent issue
                    if issue.parent_id
                      if copied_parent = issues_map[issue.parent_id]
                        new_issue.parent_issue_id = copied_parent.id
                      end
                    end
                    self.issues << new_issue
                    if new_issue.new_record?
                      logger.info "Project#copy_issues: issue ##{issue.id} could not be copied: #{new_issue.errors.full_messages}" if logger && logger.info?
                    else
                      issues_map[issue.id] = new_issue unless new_issue.new_record?
                    end
                  end
                  # Restore locked/closed version statuses
                  version_statuses.each do |version, status|
                    version.update_attribute :status, status
                  end
                  # Relations after in case issues related each other
                  project.issues.each do |issue|
                    new_issue = issues_map[issue.id]
                    unless new_issue
                      # Issue was not copied
                      next
                    end
                    # Relations
                    issue.relations_from.each do |source_relation|
                      new_issue_relation = IssueRelation.new
                      new_issue_relation.attributes = source_relation.attributes.dup.except("id", "issue_from_id", "issue_to_id")
                      new_issue_relation.issue_to = issues_map[source_relation.issue_to_id]
                      if new_issue_relation.issue_to.nil? && Setting.cross_project_issue_relations?
                        new_issue_relation.issue_to = source_relation.issue_to
                      end
                      new_issue.relations_from << new_issue_relation
                    end
                    issue.relations_to.each do |source_relation|
                      new_issue_relation = IssueRelation.new
                      new_issue_relation.attributes = source_relation.attributes.dup.except("id", "issue_from_id", "issue_to_id")
                      new_issue_relation.issue_from = issues_map[source_relation.issue_from_id]
                      if new_issue_relation.issue_from.nil? && Setting.cross_project_issue_relations?
                        new_issue_relation.issue_from = source_relation.issue_from
                      end
                      new_issue.relations_to << new_issue_relation
                    end
                  end
                end
                # Copies members from +project+
                def copy_members(project)
                  # Copy users first, then groups to handle members with inherited and given roles
                  members_to_copy = []
                  members_to_copy += project.memberships.select {|m| m.principal.is_a?(User)}
                  members_to_copy += project.memberships.select {|m| !m.principal.is_a?(User)}
                  members_to_copy.each do |member|
                    new_member = Member.new
                    new_member.attributes = member.attributes.dup.except("id", "project_id", "created_on")
                    # only copy non inherited roles
                    # inherited roles will be added when copying the group membership
                    role_ids = member.member_roles.reject(&:inherited?).collect(&:role_id)
                    next if role_ids.empty?
                    new_member.role_ids = role_ids
                    new_member.project = self
                    self.members << new_member
                  end
                end
                # Copies queries from +project+
                def copy_queries(project)
                  project.queries.each do |query|
                    new_query = IssueQuery.new
                    new_query.attributes = query.attributes.dup.except("id", "project_id", "sort_criteria", "user_id", "type")
                    new_query.sort_criteria = query.sort_criteria if query.sort_criteria
                    new_query.project = self
                    new_query.user_id = query.user_id
                    new_query.role_ids = query.role_ids if query.visibility == IssueQuery::VISIBILITY_ROLES
                    self.queries << new_query
                  end
                end
                # Copies boards from +project+
                def copy_boards(project)
                  project.boards.each do |board|
                    new_board = Board.new
                    new_board.attributes = board.attributes.dup.except("id", "project_id", "topics_count", "messages_count", "last_message_id")
                    new_board.project = self
                    self.boards << new_board
                  end
                end
                def allowed_permissions
                  @allowed_permissions ||= begin
                    module_names = enabled_modules.loaded? ? enabled_modules.map(&:name) : enabled_modules.pluck(:name)
                    Redmine::AccessControl.modules_permissions(module_names).collect {|p| p.name}
                  end
                end
                def allowed_actions
                  @actions_allowed ||= allowed_permissions.inject([]) { |actions, permission| actions += Redmine::AccessControl.allowed_actions(permission) }.flatten
                end
                # Archives subprojects recursively
                def archive!
                  children.each do |subproject|
                    subproject.send :archive!
                  end
                  update_attribute :status, STATUS_ARCHIVED
                end
              end

db/migrate/098_set_topic_authors_as_watchers.rb +1 -1

              class SetTopicAuthorsAsWatchers < ActiveRecord::Migration
                def self.up
                  # Sets active users who created/replied a topic as watchers of the topic
                  # so that the new watch functionality at topic level doesn't affect notifications behaviour
                  Message.connection.execute("INSERT INTO #{Watcher.table_name} (watchable_type, watchable_id, user_id)" +
                                               " SELECT DISTINCT 'Message', COALESCE(m.parent_id, m.id), m.author_id" +
                                               " FROM #{Message.table_name} m, #{User.table_name} u" +
                                               " WHERE m.author_id = u.id AND u.status = 1")
                end
                def self.down
                  # Removes all message watchers
-                 Watcher.delete_all("watchable_type = 'Message'")
+                 Watcher.where("watchable_type = 'Message'").delete_all
                end
              end

db/migrate/20100819172912_enable_calendar_and_gantt_modules_where_appropriate.rb +1 -1

              class EnableCalendarAndGanttModulesWhereAppropriate < ActiveRecord::Migration
                def self.up
                  EnabledModule.where(:name => 'issue_tracking').each do |e|
                    EnabledModule.create(:name => 'calendar', :project_id => e.project_id)
                    EnabledModule.create(:name => 'gantt', :project_id => e.project_id)
                  end
                end
                def self.down
-                 EnabledModule.delete_all("name = 'calendar' OR name = 'gantt'")
+                 EnabledModule.where("name = 'calendar' OR name = 'gantt'").delete_all
                end
              end

db/migrate/20101104182107_add_unique_index_on_members.rb +2 -2

              class AddUniqueIndexOnMembers < ActiveRecord::Migration
                def self.up
                  # Clean and reassign MemberRole rows if needed
-                 MemberRole.delete_all("member_id NOT IN (SELECT id FROM #{Member.table_name})")
+                 MemberRole.where("member_id NOT IN (SELECT id FROM #{Member.table_name})").delete_all
                  MemberRole.update_all("member_id =" +
                    " (SELECT min(m2.id) FROM #{Member.table_name} m1, #{Member.table_name} m2" +
                    " WHERE m1.user_id = m2.user_id AND m1.project_id = m2.project_id" +
                    " AND m1.id = #{MemberRole.table_name}.member_id)")
                  # Remove duplicates
                  Member.connection.select_values("SELECT m.id FROM #{Member.table_name} m" +
                    " WHERE m.id > (SELECT min(m1.id) FROM #{Member.table_name} m1 WHERE m1.user_id = m.user_id AND m1.project_id = m.project_id)").each do |i|
-                     Member.delete_all(["id = ?", i])
+                     Member.where(["id = ?", i]).delete_all
                    end
                  # Then add a unique index
                  add_index :members, [:user_id, :project_id], :unique => true
                end
                def self.down
                  remove_index :members, [:user_id, :project_id]
                end
              end

db/migrate/20111201201315_add_unique_index_to_issue_relations.rb +1 -1

              class AddUniqueIndexToIssueRelations < ActiveRecord::Migration
                def self.up
                  # Remove duplicates
                  IssueRelation.connection.select_values("SELECT r.id FROM #{IssueRelation.table_name} r" +
                    " WHERE r.id > (SELECT min(r1.id) FROM #{IssueRelation.table_name} r1 WHERE r1.issue_from_id = r.issue_from_id AND r1.issue_to_id = r.issue_to_id)").each do |i|
-                     IssueRelation.delete_all(["id = ?", i])
+                     IssueRelation.where(["id = ?", i]).delete_all
                  end
                  add_index :issue_relations, [:issue_from_id, :issue_to_id], :unique => true
                end
                def self.down
                  remove_index :issue_relations, :column => [:issue_from_id, :issue_to_id]
                end
              end

lib/tasks/migrate_from_mantis.rake +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              desc 'Mantis migration script'
              require 'active_record'
              require 'pp'
              namespace :redmine do
              task :migrate_from_mantis => :environment do
                module MantisMigrate
                    new_status = IssueStatus.find_by_position(1)
                    assigned_status = IssueStatus.find_by_position(2)
                    resolved_status = IssueStatus.find_by_position(3)
                    feedback_status = IssueStatus.find_by_position(4)
                    closed_status = IssueStatus.where(:is_closed => true).first
                    STATUS_MAPPING = {10 => new_status,      # new
 => feedback_status, # feedback
 => new_status,      # acknowledged
 => new_status,      # confirmed
 => assigned_status, # assigned
 => resolved_status, # resolved
 => closed_status    # closed
                                      }
                    priorities = IssuePriority.all
                    DEFAULT_PRIORITY = priorities[2]
                    PRIORITY_MAPPING = {10 => priorities[1], # none
 => priorities[1], # low
 => priorities[2], # normal
 => priorities[3], # high
 => priorities[4], # urgent
 => priorities[5]  # immediate
                                        }
                    TRACKER_BUG = Tracker.find_by_position(1)
                    TRACKER_FEATURE = Tracker.find_by_position(2)
                    roles = Role.where(:builtin => 0).order('position ASC').all
                    manager_role = roles[0]
                    developer_role = roles[1]
                    DEFAULT_ROLE = roles.last
                    ROLE_MAPPING = {10 => DEFAULT_ROLE,   # viewer
 => DEFAULT_ROLE,   # reporter
 => DEFAULT_ROLE,   # updater
 => developer_role, # developer
 => manager_role,   # manager
 => manager_role    # administrator
                                    }
                    CUSTOM_FIELD_TYPE_MAPPING = {0 => 'string', # String
 => 'int',    # Numeric
 => 'int',    # Float
 => 'list',   # Enumeration
 => 'string', # Email
 => 'bool',   # Checkbox
 => 'list',   # List
 => 'list',   # Multiselection list
 => 'date',   # Date
                                                 }
                    RELATION_TYPE_MAPPING = {1 => IssueRelation::TYPE_RELATES,    # related to
 => IssueRelation::TYPE_RELATES,    # parent of
 => IssueRelation::TYPE_RELATES,    # child of
 => IssueRelation::TYPE_DUPLICATES, # duplicate of
 => IssueRelation::TYPE_DUPLICATES  # has duplicate
                                             }
                  class MantisUser < ActiveRecord::Base
                    self.table_name = :mantis_user_table
                    def firstname
                      @firstname = realname.blank? ? username : realname.split.first[0..29]
                      @firstname
                    end
                    def lastname
                      @lastname = realname.blank? ? '-' : realname.split[1..-1].join(' ')[0..29]
                      @lastname = '-' if @lastname.blank?
                      @lastname
                    end
                    def email
                      if read_attribute(:email).match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) &&
                           !User.find_by_mail(read_attribute(:email))
                        @email = read_attribute(:email)
                      else
                        @email = "#{username}@foo.bar"
                      end
                    end
                    def username
                      read_attribute(:username)[0..29].gsub(/[^a-zA-Z0-9_\-@\.]/, '-')
                    end
                  end
                  class MantisProject < ActiveRecord::Base
                    self.table_name = :mantis_project_table
                    has_many :versions, :class_name => "MantisVersion", :foreign_key => :project_id
                    has_many :categories, :class_name => "MantisCategory", :foreign_key => :project_id
                    has_many :news, :class_name => "MantisNews", :foreign_key => :project_id
                    has_many :members, :class_name => "MantisProjectUser", :foreign_key => :project_id
                    def identifier
                      read_attribute(:name).downcase.gsub(/[^a-z0-9\-]+/, '-').slice(0, Project::IDENTIFIER_MAX_LENGTH)
                    end
                  end
                  class MantisVersion < ActiveRecord::Base
                    self.table_name = :mantis_project_version_table
                    def version
                      read_attribute(:version)[0..29]
                    end
                    def description
                      read_attribute(:description)[0..254]
                    end
                  end
                  class MantisCategory < ActiveRecord::Base
                    self.table_name = :mantis_project_category_table
                  end
                  class MantisProjectUser < ActiveRecord::Base
                    self.table_name = :mantis_project_user_list_table
                  end
                  class MantisBug < ActiveRecord::Base
                    self.table_name = :mantis_bug_table
                    belongs_to :bug_text, :class_name => "MantisBugText", :foreign_key => :bug_text_id
                    has_many :bug_notes, :class_name => "MantisBugNote", :foreign_key => :bug_id
                    has_many :bug_files, :class_name => "MantisBugFile", :foreign_key => :bug_id
                    has_many :bug_monitors, :class_name => "MantisBugMonitor", :foreign_key => :bug_id
                  end
                  class MantisBugText < ActiveRecord::Base
                    self.table_name = :mantis_bug_text_table
                    # Adds Mantis steps_to_reproduce and additional_information fields
                    # to description if any
                    def full_description
                      full_description = description
                      full_description += "\n\n*Steps to reproduce:*\n\n#{steps_to_reproduce}" unless steps_to_reproduce.blank?
                      full_description += "\n\n*Additional information:*\n\n#{additional_information}" unless additional_information.blank?
                      full_description
                    end
                  end
                  class MantisBugNote < ActiveRecord::Base
                    self.table_name = :mantis_bugnote_table
                    belongs_to :bug, :class_name => "MantisBug", :foreign_key => :bug_id
                    belongs_to :bug_note_text, :class_name => "MantisBugNoteText", :foreign_key => :bugnote_text_id
                  end
                  class MantisBugNoteText < ActiveRecord::Base
                    self.table_name = :mantis_bugnote_text_table
                  end
                  class MantisBugFile < ActiveRecord::Base
                    self.table_name = :mantis_bug_file_table
                    def size
                      filesize
                    end
                    def original_filename
                      MantisMigrate.encode(filename)
                    end
                    def content_type
                      file_type
                    end
                    def read(*args)
                        if @read_finished
                            nil
                        else
                            @read_finished = true
                            content
                        end
                    end
                  end
                  class MantisBugRelationship < ActiveRecord::Base
                    self.table_name = :mantis_bug_relationship_table
                  end
                  class MantisBugMonitor < ActiveRecord::Base
                    self.table_name = :mantis_bug_monitor_table
                  end
                  class MantisNews < ActiveRecord::Base
                    self.table_name = :mantis_news_table
                  end
                  class MantisCustomField < ActiveRecord::Base
                    self.table_name = :mantis_custom_field_table
                    set_inheritance_column :none
                    has_many :values, :class_name => "MantisCustomFieldString", :foreign_key => :field_id
                    has_many :projects, :class_name => "MantisCustomFieldProject", :foreign_key => :field_id
                    def format
                      read_attribute :type
                    end
                    def name
                      read_attribute(:name)[0..29]
                    end
                  end
                  class MantisCustomFieldProject < ActiveRecord::Base
                    self.table_name = :mantis_custom_field_project_table
                  end
                  class MantisCustomFieldString < ActiveRecord::Base
                    self.table_name = :mantis_custom_field_string_table
                  end
                  def self.migrate
                    # Users
                    print "Migrating users"
-                   User.delete_all "login <> 'admin'"
+                   User.where("login <> 'admin'").delete_all
                    users_map = {}
                    users_migrated = 0
                    MantisUser.all.each do |user|
                      u = User.new :firstname => encode(user.firstname),
                                   :lastname => encode(user.lastname),
                                   :mail => user.email,
                                   :last_login_on => user.last_visit
                      u.login = user.username
                      u.password = 'mantis'
                      u.status = User::STATUS_LOCKED if user.enabled != 1
                      u.admin = true if user.access_level == 90
                      next unless u.save!
                      users_migrated += 1
                      users_map[user.id] = u.id
                      print '.'
                    end
                    puts
                    # Projects
                    print "Migrating projects"
                    Project.destroy_all
                    projects_map = {}
                    versions_map = {}
                    categories_map = {}
                    MantisProject.all.each do |project|
                      p = Project.new :name => encode(project.name),
                                      :description => encode(project.description)
                      p.identifier = project.identifier
                      next unless p.save
                      projects_map[project.id] = p.id
                      p.enabled_module_names = ['issue_tracking', 'news', 'wiki']
                      p.trackers << TRACKER_BUG unless p.trackers.include?(TRACKER_BUG)
                      p.trackers << TRACKER_FEATURE unless p.trackers.include?(TRACKER_FEATURE)
                      print '.'
                      # Project members
                      project.members.each do |member|
                        m = Member.new :user => User.find_by_id(users_map[member.user_id]),
                                         :roles => [ROLE_MAPPING[member.access_level] || DEFAULT_ROLE]
                        m.project = p
                        m.save
                      end
                      # Project versions
                      project.versions.each do |version|
                        v = Version.new :name => encode(version.version),
                                        :description => encode(version.description),
                                        :effective_date => (version.date_order ? version.date_order.to_date : nil)
                        v.project = p
                        v.save
                        versions_map[version.id] = v.id
                      end
                      # Project categories
                      project.categories.each do |category|
                        g = IssueCategory.new :name => category.category[0,30]
                        g.project = p
                        g.save
                        categories_map[category.category] = g.id
                      end
                    end
                    puts
                    # Bugs
                    print "Migrating bugs"
                    Issue.destroy_all
                    issues_map = {}
                    keep_bug_ids = (Issue.count == 0)
                    MantisBug.find_each(:batch_size => 200) do |bug|
                      next unless projects_map[bug.project_id] && users_map[bug.reporter_id]
                      i = Issue.new :project_id => projects_map[bug.project_id],
                                    :subject => encode(bug.summary),
                                    :description => encode(bug.bug_text.full_description),
                                    :priority => PRIORITY_MAPPING[bug.priority] || DEFAULT_PRIORITY,
                                    :created_on => bug.date_submitted,
                                    :updated_on => bug.last_updated
                      i.author = User.find_by_id(users_map[bug.reporter_id])
                      i.category = IssueCategory.find_by_project_id_and_name(i.project_id, bug.category[0,30]) unless bug.category.blank?
                      i.fixed_version = Version.find_by_project_id_and_name(i.project_id, bug.fixed_in_version) unless bug.fixed_in_version.blank?
                      i.tracker = (bug.severity == 10 ? TRACKER_FEATURE : TRACKER_BUG)
                      i.status = STATUS_MAPPING[bug.status] || i.status
                      i.id = bug.id if keep_bug_ids
                      next unless i.save
                      issues_map[bug.id] = i.id
                      print '.'
                      STDOUT.flush
                      # Assignee
                      # Redmine checks that the assignee is a project member
                      if (bug.handler_id && users_map[bug.handler_id])
                        i.assigned_to = User.find_by_id(users_map[bug.handler_id])
                        i.save(:validate => false)
                      end
                      # Bug notes
                      bug.bug_notes.each do |note|
                        next unless users_map[note.reporter_id]
                        n = Journal.new :notes => encode(note.bug_note_text.note),
                                        :created_on => note.date_submitted
                        n.user = User.find_by_id(users_map[note.reporter_id])
                        n.journalized = i
                        n.save
                      end
                      # Bug files
                      bug.bug_files.each do |file|
                        a = Attachment.new :created_on => file.date_added
                        a.file = file
                        a.author = User.first
                        a.container = i
                        a.save
                      end
                      # Bug monitors
                      bug.bug_monitors.each do |monitor|
                        next unless users_map[monitor.user_id]
                        i.add_watcher(User.find_by_id(users_map[monitor.user_id]))
                      end
                    end
                    # update issue id sequence if needed (postgresql)
                    Issue.connection.reset_pk_sequence!(Issue.table_name) if Issue.connection.respond_to?('reset_pk_sequence!')
                    puts
                    # Bug relationships
                    print "Migrating bug relations"
                    MantisBugRelationship.all.each do |relation|
                      next unless issues_map[relation.source_bug_id] && issues_map[relation.destination_bug_id]
                      r = IssueRelation.new :relation_type => RELATION_TYPE_MAPPING[relation.relationship_type]
                      r.issue_from = Issue.find_by_id(issues_map[relation.source_bug_id])
                      r.issue_to = Issue.find_by_id(issues_map[relation.destination_bug_id])
                      pp r unless r.save
                      print '.'
                      STDOUT.flush
                    end
                    puts
                    # News
                    print "Migrating news"
                    News.destroy_all
                    MantisNews.where('project_id > 0').all.each do |news|
                      next unless projects_map[news.project_id]
                      n = News.new :project_id => projects_map[news.project_id],
                                   :title => encode(news.headline[0..59]),
                                   :description => encode(news.body),
                                   :created_on => news.date_posted
                      n.author = User.find_by_id(users_map[news.poster_id])
                      n.save
                      print '.'
                      STDOUT.flush
                    end
                    puts
                    # Custom fields
                    print "Migrating custom fields"
                    IssueCustomField.destroy_all
                    MantisCustomField.all.each do |field|
                      f = IssueCustomField.new :name => field.name[0..29],
                                               :field_format => CUSTOM_FIELD_TYPE_MAPPING[field.format],
                                               :min_length => field.length_min,
                                               :max_length => field.length_max,
                                               :regexp => field.valid_regexp,
                                               :possible_values => field.possible_values.split('|'),
                                               :is_required => field.require_report?
                      next unless f.save
                      print '.'
                      STDOUT.flush
                      # Trackers association
                      f.trackers = Tracker.all
                      # Projects association
                      field.projects.each do |project|
                        f.projects << Project.find_by_id(projects_map[project.project_id]) if projects_map[project.project_id]
                      end
                      # Values
                      field.values.each do |value|
                        v = CustomValue.new :custom_field_id => f.id,
                                            :value => value.value
                        v.customized = Issue.find_by_id(issues_map[value.bug_id]) if issues_map[value.bug_id]
                        v.save
                      end unless f.new_record?
                    end
                    puts
                    puts
                    puts "Users:           #{users_migrated}/#{MantisUser.count}"
                    puts "Projects:        #{Project.count}/#{MantisProject.count}"
                    puts "Memberships:     #{Member.count}/#{MantisProjectUser.count}"
                    puts "Versions:        #{Version.count}/#{MantisVersion.count}"
                    puts "Categories:      #{IssueCategory.count}/#{MantisCategory.count}"
                    puts "Bugs:            #{Issue.count}/#{MantisBug.count}"
                    puts "Bug notes:       #{Journal.count}/#{MantisBugNote.count}"
                    puts "Bug files:       #{Attachment.count}/#{MantisBugFile.count}"
                    puts "Bug relations:   #{IssueRelation.count}/#{MantisBugRelationship.count}"
                    puts "Bug monitors:    #{Watcher.count}/#{MantisBugMonitor.count}"
                    puts "News:            #{News.count}/#{MantisNews.count}"
                    puts "Custom fields:   #{IssueCustomField.count}/#{MantisCustomField.count}"
                  end
                  def self.encoding(charset)
                    @charset = charset
                  end
                  def self.establish_connection(params)
                    constants.each do |const|
                      klass = const_get(const)
                      next unless klass.respond_to? 'establish_connection'
                      klass.establish_connection params
                    end
                  end
                  def self.encode(text)
                    text.to_s.force_encoding(@charset).encode('UTF-8')
                  end
                end
                puts
                if Redmine::DefaultData::Loader.no_data?
                  puts "Redmine configuration need to be loaded before importing data."
                  puts "Please, run this first:"
                  puts
                  puts "  rake redmine:load_default_data RAILS_ENV=\"#{ENV['RAILS_ENV']}\""
                  exit
                end
                puts "WARNING: Your Redmine data will be deleted during this process."
                print "Are you sure you want to continue ? [y/N] "
                STDOUT.flush
                break unless STDIN.gets.match(/^y$/i)
                # Default Mantis database settings
                db_params = {:adapter => 'mysql2',
                             :database => 'bugtracker',
                             :host => 'localhost',
                             :username => 'root',
                             :password => '' }
                puts
                puts "Please enter settings for your Mantis database"
                [:adapter, :host, :database, :username, :password].each do |param|
                  print "#{param} [#{db_params[param]}]: "
                  value = STDIN.gets.chomp!
                  db_params[param] = value unless value.blank?
                end
                while true
                  print "encoding [UTF-8]: "
                  STDOUT.flush
                  encoding = STDIN.gets.chomp!
                  encoding = 'UTF-8' if encoding.blank?
                  break if MantisMigrate.encoding encoding
                  puts "Invalid encoding!"
                end
                puts
                # Make sure bugs can refer bugs in other projects
                Setting.cross_project_issue_relations = 1 if Setting.respond_to? 'cross_project_issue_relations'
                old_notified_events = Setting.notified_events
                old_password_min_length = Setting.password_min_length
                begin
                  # Turn off email notifications temporarily
                  Setting.notified_events = []
                  Setting.password_min_length = 4
                  # Run the migration
                  MantisMigrate.establish_connection db_params
                  MantisMigrate.migrate
                ensure
                  # Restore previous settings
                  Setting.notified_events = old_notified_events
                  Setting.password_min_length = old_password_min_length
                end
              end
              end

test/functional/admin_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class AdminControllerTest < Redmine::ControllerTest
                fixtures :projects, :users, :email_addresses, :roles
                def setup
                  User.current = nil
                  @request.session[:user_id] = 1 # admin
                end
                def test_index
                  get :index
                  assert_select 'div.nodata', 0
                end
                def test_index_with_no_configuration_data
                  delete_configuration_data
                  get :index
                  assert_select 'div.nodata'
                end
                def test_projects
                  get :projects
                  assert_response :success
                  assert_template 'projects'
                  assert_not_nil assigns(:projects)
                  # active projects only
                  assert_nil assigns(:projects).detect {|u| !u.active?}
                end
                def test_projects_with_status_filter
                  get :projects, :status => 1
                  assert_response :success
                  assert_template 'projects'
                  assert_not_nil assigns(:projects)
                  # active projects only
                  assert_nil assigns(:projects).detect {|u| !u.active?}
                end
                def test_projects_with_name_filter
                  get :projects, :name => 'store', :status => ''
                  assert_response :success
                  assert_template 'projects'
                  projects = assigns(:projects)
                  assert_not_nil projects
                  assert_equal 1, projects.size
                  assert_equal 'OnlineStore', projects.first.name
                end
                def test_load_default_configuration_data
                  delete_configuration_data
                  post :default_configuration, :lang => 'fr'
                  assert_response :redirect
                  assert_nil flash[:error]
                  assert IssueStatus.find_by_name('Nouveau')
                end
                def test_load_default_configuration_data_should_rescue_error
                  delete_configuration_data
                  Redmine::DefaultData::Loader.stubs(:load).raises(Exception.new("Something went wrong"))
                  post :default_configuration, :lang => 'fr'
                  assert_response :redirect
                  assert_not_nil flash[:error]
                  assert_match /Something went wrong/, flash[:error]
                end
                def test_test_email
                  user = User.find(1)
                  user.pref.no_self_notified = '1'
                  user.pref.save!
                  ActionMailer::Base.deliveries.clear
                  post :test_email
                  assert_redirected_to '/settings?tab=notifications'
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  user = User.find(1)
                  assert_equal [user.mail], mail.bcc
                end
                def test_test_email_failure_should_display_the_error
                  Mailer.stubs(:test_email).raises(Exception, 'Some error message')
                  post :test_email
                  assert_redirected_to '/settings?tab=notifications'
                  assert_match /Some error message/, flash[:error]
                end
                def test_no_plugins
                  Redmine::Plugin.stubs(:registered_plugins).returns({})
                  get :plugins
                  assert_response :success
                  assert_template 'plugins'
                  assert_equal [], assigns(:plugins)
                end
                def test_plugins
                  # Register a few plugins
                  Redmine::Plugin.register :foo do
                    name 'Foo plugin'
                    author 'John Smith'
                    description 'This is a test plugin'
                    version '0.0.1'
                    settings :default => {'sample_setting' => 'value', 'foo'=>'bar'}, :partial => 'foo/settings'
                  end
                  Redmine::Plugin.register :bar do
                  end
                  get :plugins
                  assert_response :success
                  assert_template 'plugins'
                  assert_select 'tr#plugin-foo' do
                    assert_select 'td span.name', :text => 'Foo plugin'
                    assert_select 'td.configure a[href="/settings/plugin/foo"]'
                  end
                  assert_select 'tr#plugin-bar' do
                    assert_select 'td span.name', :text => 'Bar'
                    assert_select 'td.configure a', 0
                  end
                end
                def test_info
                  get :info
                  assert_response :success
                  assert_template 'info'
                end
                def test_admin_menu_plugin_extension
                  Redmine::MenuManager.map :admin_menu do |menu|
                    menu.push :test_admin_menu_plugin_extension, '/foo/bar', :caption => 'Test'
                  end
                  get :index
                  assert_response :success
                  assert_select 'div#admin-menu a[href="/foo/bar"]', :text => 'Test'
                  Redmine::MenuManager.map :admin_menu do |menu|
                    menu.delete :test_admin_menu_plugin_extension
                  end
                end
                private
                def delete_configuration_data
-                 Role.delete_all('builtin = 0')
+                 Role.where('builtin = 0').delete_all
                  Tracker.delete_all
                  IssueStatus.delete_all
                  Enumeration.delete_all
                end
              end

test/functional/issues_controller_test.rb 0 0

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

test/unit/default_data_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class DefaultDataTest < ActiveSupport::TestCase
                include Redmine::I18n
                fixtures :roles
                def test_no_data
                  assert !Redmine::DefaultData::Loader::no_data?
-                 Role.delete_all("builtin = 0")
+                 Role.where("builtin = 0").delete_all
                  Tracker.delete_all
                  IssueStatus.delete_all
                  Enumeration.delete_all
                  assert Redmine::DefaultData::Loader::no_data?
                end
                def test_load
                  valid_languages.each do |lang|
                    begin
-                     Role.delete_all("builtin = 0")
+                     Role.where("builtin = 0").delete_all
                      Tracker.delete_all
                      IssueStatus.delete_all
                      Enumeration.delete_all
                      assert Redmine::DefaultData::Loader::load(lang)
                      assert_not_nil DocumentCategory.first
                      assert_not_nil IssuePriority.first
                      assert_not_nil TimeEntryActivity.first
                    rescue ActiveRecord::RecordInvalid => e
                      assert false, ":#{lang} default data is invalid (#{e.message})."
                    end
                  end
                end
              end

test/unit/news_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class NewsTest < ActiveSupport::TestCase
                fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles, :enabled_modules, :news
                def valid_news
                  { :title => 'Test news', :description => 'Lorem ipsum etc', :author => User.first }
                end
                def setup
                end
                def test_create_should_send_email_notification
                  ActionMailer::Base.deliveries.clear
                  news = Project.find(1).news.new(valid_news)
                  with_settings :notified_events => %w(news_added) do
                    assert news.save
                  end
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_should_include_news_for_projects_with_news_enabled
                  project = projects(:projects_001)
                  assert project.enabled_modules.any?{ |em| em.name == 'news' }
                  # News.latest should return news from projects_001
                  assert News.latest.any? { |news| news.project == project }
                end
                def test_should_not_include_news_for_projects_with_news_disabled
-                 EnabledModule.delete_all(["project_id = ? AND name = ?", 2, 'news'])
+                 EnabledModule.where(["project_id = ? AND name = ?", 2, 'news']).delete_all
                  project = Project.find(2)
                  # Add a piece of news to the project
                  news = project.news.create(valid_news)
                  # News.latest should not return that new piece of news
                  assert News.latest.include?(news) == false
                end
                def test_should_only_include_news_from_projects_visibly_to_the_user
                  assert News.latest(User.anonymous).all? { |news| news.project.is_public? }
                end
                def test_should_limit_the_amount_of_returned_news
                  # Make sure we have a bunch of news stories
 .times { projects(:projects_001).news.create(valid_news) }
                  assert_equal 2, News.latest(users(:users_002), 2).size
                  assert_equal 6, News.latest(users(:users_002), 6).size
                end
                def test_should_return_5_news_stories_by_default
                  # Make sure we have a bunch of news stories
 .times { projects(:projects_001).news.create(valid_news) }
                  assert_equal 5, News.latest(users(:users_004)).size
                end
                def test_attachments_should_be_visible
                  assert News.find(1).attachments_visible?(User.anonymous)
                end
                def test_attachments_should_be_deletable_with_manage_news_permission
                  manager = User.find(2)
                  assert News.find(1).attachments_deletable?(manager)
                end
                def test_attachments_should_not_be_deletable_without_manage_news_permission
                  manager = User.find(2)
                  Role.find_by_name('Manager').remove_permission!(:manage_news)
                  assert !News.find(1).attachments_deletable?(manager)
                end
              end

test/unit/user_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class UserTest < ActiveSupport::TestCase
                fixtures :users, :email_addresses, :members, :projects, :roles, :member_roles, :auth_sources,
                          :trackers, :issue_statuses,
                          :projects_trackers,
                          :watchers,
                          :issue_categories, :enumerations, :issues,
                          :journals, :journal_details,
                          :groups_users,
                          :enabled_modules,
                          :tokens
                include Redmine::I18n
                def setup
                  @admin = User.find(1)
                  @jsmith = User.find(2)
                  @dlopper = User.find(3)
                end
                def test_sorted_scope_should_sort_user_by_display_name
                  # Use .active to ignore anonymous with localized display name
                  assert_equal User.active.map(&:name).map(&:downcase).sort,
                               User.active.sorted.map(&:name).map(&:downcase)
                end
                def test_generate
                  User.generate!(:firstname => 'Testing connection')
                  User.generate!(:firstname => 'Testing connection')
                  assert_equal 2, User.where(:firstname => 'Testing connection').count
                end
                def test_truth
                  assert_kind_of User, @jsmith
                end
                def test_should_validate_status
                  user = User.new
                  user.status = 0
                  assert !user.save
                  assert_include I18n.translate('activerecord.errors.messages.invalid'), user.errors[:status]
                end
                def test_mail_should_be_stripped
                  u = User.new
                  u.mail = " foo@bar.com  "
                  assert_equal "foo@bar.com", u.mail
                end
                def test_should_create_email_address
                  u = User.new(:firstname => "new", :lastname => "user")
                  u.login = "create_email_address"
                  u.mail = "defaultemail@somenet.foo"
                  assert u.save
                  u.reload
                  assert u.email_address
                  assert_equal "defaultemail@somenet.foo", u.email_address.address
                  assert_equal true, u.email_address.is_default
                  assert_equal true, u.email_address.notify
                end
                def test_should_not_create_user_without_mail
                  set_language_if_valid 'en'
                  u = User.new(:firstname => "new", :lastname => "user")
                  u.login = "user_without_mail"
                  assert !u.save
                  assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
                end
                def test_should_not_create_user_with_blank_mail
                  set_language_if_valid 'en'
                  u = User.new(:firstname => "new", :lastname => "user")
                  u.login = "user_with_blank_mail"
                  u.mail = ''
                  assert !u.save
                  assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
                end
                def test_should_not_update_user_with_blank_mail
                  set_language_if_valid 'en'
                  u = User.find(2)
                  u.mail = ''
                  assert !u.save
                  assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
                end
                def test_login_length_validation
                  user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  user.login = "x" * (User::LOGIN_LENGTH_LIMIT+1)
                  assert !user.valid?
                  user.login = "x" * (User::LOGIN_LENGTH_LIMIT)
                  assert user.valid?
                  assert user.save
                end
                def test_generate_password_should_respect_minimum_password_length
                  with_settings :password_min_length => 15 do
                    user = User.generate!(:generate_password => true)
                    assert user.password.length >= 15
                  end
                end
                def test_generate_password_should_not_generate_password_with_less_than_10_characters
                  with_settings :password_min_length => 4 do
                    user = User.generate!(:generate_password => true)
                    assert user.password.length >= 10
                  end
                end
                def test_generate_password_on_create_should_set_password
                  user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  user.login = "newuser"
                  user.generate_password = true
                  assert user.save
                  password = user.password
                  assert user.check_password?(password)
                end
                def test_generate_password_on_update_should_update_password
                  user = User.find(2)
                  hash = user.hashed_password
                  user.generate_password = true
                  assert user.save
                  password = user.password
                  assert user.check_password?(password)
                  assert_not_equal hash, user.reload.hashed_password
                end
                def test_create
                  user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  user.login = "jsmith"
                  user.password, user.password_confirmation = "password", "password"
                  # login uniqueness
                  assert !user.save
                  assert_equal 1, user.errors.count
                  user.login = "newuser"
                  user.password, user.password_confirmation = "password", "pass"
                  # password confirmation
                  assert !user.save
                  assert_equal 1, user.errors.count
                  user.password, user.password_confirmation = "password", "password"
                  assert user.save
                end
                def test_user_before_create_should_set_the_mail_notification_to_the_default_setting
                  @user1 = User.generate!
                  assert_equal 'only_my_events', @user1.mail_notification
                  with_settings :default_notification_option => 'all' do
                    @user2 = User.generate!
                    assert_equal 'all', @user2.mail_notification
                  end
                end
                def test_user_login_should_be_case_insensitive
                  u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  u.login = 'newuser'
                  u.password, u.password_confirmation = "password", "password"
                  assert u.save
                  u = User.new(:firstname => "Similar", :lastname => "User",
                               :mail => "similaruser@somenet.foo")
                  u.login = 'NewUser'
                  u.password, u.password_confirmation = "password", "password"
                  assert !u.save
                  assert_include I18n.translate('activerecord.errors.messages.taken'), u.errors[:login]
                end
                def test_mail_uniqueness_should_not_be_case_sensitive
                  set_language_if_valid 'en'
                  u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  u.login = 'newuser1'
                  u.password, u.password_confirmation = "password", "password"
                  assert u.save
                  u = User.new(:firstname => "new", :lastname => "user", :mail => "newUser@Somenet.foo")
                  u.login = 'newuser2'
                  u.password, u.password_confirmation = "password", "password"
                  assert !u.save
                  assert_include "Email #{I18n.translate('activerecord.errors.messages.taken')}", u.errors.full_messages
                end
                def test_update
                  assert_equal "admin", @admin.login
                  @admin.login = "john"
                  assert @admin.save, @admin.errors.full_messages.join("; ")
                  @admin.reload
                  assert_equal "john", @admin.login
                end
                def test_update_should_not_fail_for_legacy_user_with_different_case_logins
                  u1 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser1@somenet.foo")
                  u1.login = 'newuser1'
                  assert u1.save
                  u2 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser2@somenet.foo")
                  u2.login = 'newuser1'
                  assert u2.save(:validate => false)
                  user = User.find(u2.id)
                  user.firstname = "firstname"
                  assert user.save, "Save failed"
                end
                def test_destroy_should_delete_members_and_roles
                  members = Member.where(:user_id => 2)
                  ms = members.count
                  rs = members.collect(&:roles).flatten.size
                  assert ms > 0
                  assert rs > 0
                  assert_difference 'Member.count', - ms do
                    assert_difference 'MemberRole.count', - rs do
                      User.find(2).destroy
                    end
                  end
                  assert_nil User.find_by_id(2)
                  assert_equal 0, Member.where(:user_id => 2).count
                end
                def test_destroy_should_update_attachments
                  attachment = Attachment.create!(:container => Project.find(1),
                    :file => uploaded_test_file("testfile.txt", "text/plain"),
                    :author_id => 2)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, attachment.reload.author
                end
                def test_destroy_should_update_comments
                  comment = Comment.create!(
                    :commented => News.create!(:project_id => 1,
                                               :author_id => 1, :title => 'foo', :description => 'foo'),
                    :author => User.find(2),
                    :comments => 'foo'
                  )
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, comment.reload.author
                end
                def test_destroy_should_update_issues
                  issue = Issue.create!(:project_id => 1, :author_id => 2,
                                        :tracker_id => 1, :subject => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, issue.reload.author
                end
                def test_destroy_should_unassign_issues
                  issue = Issue.create!(:project_id => 1, :author_id => 1,
                                        :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil issue.reload.assigned_to
                end
                def test_destroy_should_update_journals
                  issue = Issue.create!(:project_id => 1, :author_id => 2,
                                        :tracker_id => 1, :subject => 'foo')
                  issue.init_journal(User.find(2), "update")
                  issue.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, issue.journals.first.reload.user
                end
                def test_destroy_should_update_journal_details_old_value
                  issue = Issue.create!(:project_id => 1, :author_id => 1,
                                        :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
                  issue.init_journal(User.find(1), "update")
                  issue.assigned_to_id = nil
                  assert_difference 'JournalDetail.count' do
                    issue.save!
                  end
                  journal_detail = JournalDetail.order('id DESC').first
                  assert_equal '2', journal_detail.old_value
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous.id.to_s, journal_detail.reload.old_value
                end
                def test_destroy_should_update_journal_details_value
                  issue = Issue.create!(:project_id => 1, :author_id => 1,
                                        :tracker_id => 1, :subject => 'foo')
                  issue.init_journal(User.find(1), "update")
                  issue.assigned_to_id = 2
                  assert_difference 'JournalDetail.count' do
                    issue.save!
                  end
                  journal_detail = JournalDetail.order('id DESC').first
                  assert_equal '2', journal_detail.value
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous.id.to_s, journal_detail.reload.value
                end
                def test_destroy_should_update_messages
                  board = Board.create!(:project_id => 1, :name => 'Board', :description => 'Board')
                  message = Message.create!(:board_id => board.id, :author_id => 2,
                                            :subject => 'foo', :content => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, message.reload.author
                end
                def test_destroy_should_update_news
                  news = News.create!(:project_id => 1, :author_id => 2,
                                      :title => 'foo', :description => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, news.reload.author
                end
                def test_destroy_should_delete_private_queries
                  query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PRIVATE)
                  query.project_id = 1
                  query.user_id = 2
                  query.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Query.find_by_id(query.id)
                end
                def test_destroy_should_update_public_queries
                  query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PUBLIC)
                  query.project_id = 1
                  query.user_id = 2
                  query.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, query.reload.user
                end
                def test_destroy_should_update_time_entries
                  entry = TimeEntry.new(:hours => '2', :spent_on => Date.today,
                                        :activity => TimeEntryActivity.create!(:name => 'foo'))
                  entry.project_id = 1
                  entry.user_id = 2
                  entry.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, entry.reload.user
                end
                def test_destroy_should_delete_tokens
                  token = Token.create!(:user_id => 2, :value => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Token.find_by_id(token.id)
                end
                def test_destroy_should_delete_watchers
                  issue = Issue.create!(:project_id => 1, :author_id => 1,
                                        :tracker_id => 1, :subject => 'foo')
                  watcher = Watcher.create!(:user_id => 2, :watchable => issue)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Watcher.find_by_id(watcher.id)
                end
                def test_destroy_should_update_wiki_contents
                  wiki_content = WikiContent.create!(
                    :text => 'foo',
                    :author_id => 2,
                    :page => WikiPage.create!(:title => 'Foo',
                                              :wiki => Wiki.create!(:project_id => 3,
                                                                    :start_page => 'Start'))
                  )
                  wiki_content.text = 'bar'
                  assert_difference 'WikiContent::Version.count' do
                    wiki_content.save!
                  end
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, wiki_content.reload.author
                  wiki_content.versions.each do |version|
                    assert_equal User.anonymous, version.reload.author
                  end
                end
                def test_destroy_should_nullify_issue_categories
                  category = IssueCategory.create!(:project_id => 1, :assigned_to_id => 2, :name => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil category.reload.assigned_to_id
                end
                def test_destroy_should_nullify_changesets
                  changeset = Changeset.create!(
                    :repository => Repository::Subversion.create!(
                      :project_id => 1,
                      :url => 'file:///tmp',
                      :identifier => 'tmp'
                    ),
                    :revision => '12',
                    :committed_on => Time.now,
                    :committer => 'jsmith'
                    )
                  assert_equal 2, changeset.user_id
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil changeset.reload.user_id
                end
                def test_anonymous_user_should_not_be_destroyable
                  assert_no_difference 'User.count' do
                    assert_equal false, User.anonymous.destroy
                  end
                end
                def test_password_change_should_destroy_tokens
                  recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                  autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                  user = User.find(2)
                  user.password, user.password_confirmation = "a new password", "a new password"
                  assert user.save
                  assert_nil Token.find_by_id(recovery_token.id)
                  assert_nil Token.find_by_id(autologin_token.id)
                end
                def test_mail_change_should_destroy_tokens
                  recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                  autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                  user = User.find(2)
                  user.mail = "user@somwehere.com"
                  assert user.save
                  assert_nil Token.find_by_id(recovery_token.id)
                  assert_equal autologin_token, Token.find_by_id(autologin_token.id)
                end
                def test_change_on_other_fields_should_not_destroy_tokens
                  recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                  autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                  user = User.find(2)
                  user.firstname = "Bobby"
                  assert user.save
                  assert_equal recovery_token, Token.find_by_id(recovery_token.id)
                  assert_equal autologin_token, Token.find_by_id(autologin_token.id)
                end
                def test_validate_login_presence
                  @admin.login = ""
                  assert !@admin.save
                  assert_equal 1, @admin.errors.count
                end
                def test_validate_mail_notification_inclusion
                  u = User.new
                  u.mail_notification = 'foo'
                  u.save
                  assert_not_equal [], u.errors[:mail_notification]
                end
                def test_password
                  user = User.try_to_login("admin", "admin")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                  user.password = "hello123"
                  assert user.save
                  user = User.try_to_login("admin", "hello123")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                end
                def test_validate_password_length
                  with_settings :password_min_length => '100' do
                    user = User.new(:firstname => "new100",
                                    :lastname => "user100", :mail => "newuser100@somenet.foo")
                    user.login = "newuser100"
                    user.password, user.password_confirmation = "password100", "password100"
                    assert !user.save
                    assert_equal 1, user.errors.count
                  end
                end
                def test_name_format
                  assert_equal 'John S.', @jsmith.name(:firstname_lastinitial)
                  assert_equal 'Smith, John', @jsmith.name(:lastname_comma_firstname)
                  assert_equal 'J. Smith', @jsmith.name(:firstinitial_lastname)
                  assert_equal 'J.-P. Lang', User.new(:firstname => 'Jean-Philippe', :lastname => 'Lang').name(:firstinitial_lastname)
                end
                def test_name_should_use_setting_as_default_format
                  with_settings :user_format => :firstname_lastname do
                    assert_equal 'John Smith', @jsmith.reload.name
                  end
                  with_settings :user_format => :username do
                    assert_equal 'jsmith', @jsmith.reload.name
                  end
                  with_settings :user_format => :lastname do
                    assert_equal 'Smith', @jsmith.reload.name
                  end
                end
                def test_today_should_return_the_day_according_to_user_time_zone
                  preference = User.find(1).pref
                  date = Date.new(2012, 05, 15)
                  time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
                  Date.stubs(:today).returns(date)
                  Time.stubs(:now).returns(time)
                  preference.update_attribute :time_zone, 'Baku' # UTC+4
                  assert_equal '2012-05-16', User.find(1).today.to_s
                  preference.update_attribute :time_zone, 'La Paz' # UTC-4
                  assert_equal '2012-05-15', User.find(1).today.to_s
                  preference.update_attribute :time_zone, ''
                  assert_equal '2012-05-15', User.find(1).today.to_s
                end
                def test_time_to_date_should_return_the_date_according_to_user_time_zone
                  preference = User.find(1).pref
                  time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
                  preference.update_attribute :time_zone, 'Baku' # UTC+4
                  assert_equal '2012-05-16', User.find(1).time_to_date(time).to_s
                  preference.update_attribute :time_zone, 'La Paz' # UTC-4
                  assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
                  preference.update_attribute :time_zone, ''
                  assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
                end
                def test_fields_for_order_statement_should_return_fields_according_user_format_setting
                  with_settings :user_format => 'lastname_comma_firstname' do
                    assert_equal ['users.lastname', 'users.firstname', 'users.id'],
                                 User.fields_for_order_statement
                  end
                end
                def test_fields_for_order_statement_width_table_name_should_prepend_table_name
                  with_settings :user_format => 'lastname_firstname' do
                    assert_equal ['authors.lastname', 'authors.firstname', 'authors.id'],
                                 User.fields_for_order_statement('authors')
                  end
                end
                def test_fields_for_order_statement_with_blank_format_should_return_default
                  with_settings :user_format => '' do
                    assert_equal ['users.firstname', 'users.lastname', 'users.id'],
                                 User.fields_for_order_statement
                  end
                end
                def test_fields_for_order_statement_with_invalid_format_should_return_default
                  with_settings :user_format => 'foo' do
                    assert_equal ['users.firstname', 'users.lastname', 'users.id'],
                                 User.fields_for_order_statement
                  end
                end
                test ".try_to_login with good credentials should return the user" do
                  user = User.try_to_login("admin", "admin")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                end
                test ".try_to_login with wrong credentials should return nil" do
                  assert_nil User.try_to_login("admin", "foo")
                end
                def test_try_to_login_with_locked_user_should_return_nil
                  @jsmith.status = User::STATUS_LOCKED
                  @jsmith.save!
                  user = User.try_to_login("jsmith", "jsmith")
                  assert_equal nil, user
                end
                def test_try_to_login_with_locked_user_and_not_active_only_should_return_user
                  @jsmith.status = User::STATUS_LOCKED
                  @jsmith.save!
                  user = User.try_to_login("jsmith", "jsmith", false)
                  assert_equal @jsmith, user
                end
                test ".try_to_login should fall-back to case-insensitive if user login is not found as-typed" do
                  user = User.try_to_login("AdMin", "admin")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                end
                test ".try_to_login should select the exact matching user first" do
                  case_sensitive_user = User.generate! do |user|
                    user.password = "admin123"
                  end
                  # bypass validations to make it appear like existing data
                  case_sensitive_user.update_attribute(:login, 'ADMIN')
                  user = User.try_to_login("ADMIN", "admin123")
                  assert_kind_of User, user
                  assert_equal "ADMIN", user.login
                end
                if ldap_configured?
                  test "#try_to_login using LDAP with failed connection to the LDAP server" do
                    auth_source = AuthSourceLdap.find(1)
                    AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
                    assert_equal nil, User.try_to_login('edavis', 'wrong')
                  end
                  test "#try_to_login using LDAP" do
                    assert_equal nil, User.try_to_login('edavis', 'wrong')
                  end
                  test "#try_to_login using LDAP binding with user's account" do
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
                    auth_source.account_password = ''
                    auth_source.save!
                    ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)
                    ldap_user.login = 'example1'
                    ldap_user.save!
                    assert_equal ldap_user, User.try_to_login('example1', '123456')
                    assert_nil User.try_to_login('example1', '11111')
                  end
                  test "#try_to_login using LDAP on the fly registration" do
                    AuthSourceLdap.find(1).update_attribute :onthefly_register, true
                    assert_difference('User.count') do
                      assert User.try_to_login('edavis', '123456')
                    end
                    assert_no_difference('User.count') do
                      assert User.try_to_login('edavis', '123456')
                    end
                    assert_nil User.try_to_login('example1', '11111')
                  end
                  test "#try_to_login using LDAP on the fly registration and binding with user's account" do
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.update_attribute :onthefly_register, true
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
                    auth_source.account_password = ''
                    auth_source.save!
                    assert_difference('User.count') do
                      assert User.try_to_login('example1', '123456')
                    end
                    assert_no_difference('User.count') do
                      assert User.try_to_login('example1', '123456')
                    end
                    assert_nil User.try_to_login('example1', '11111')
                  end
                else
                  puts "Skipping LDAP tests."
                end
                def test_create_anonymous
                  AnonymousUser.delete_all
                  anon = User.anonymous
                  assert !anon.new_record?
                  assert_kind_of AnonymousUser, anon
                end
                def test_ensure_single_anonymous_user
                  AnonymousUser.delete_all
                  anon1 = User.anonymous
                  assert !anon1.new_record?
                  assert_kind_of AnonymousUser, anon1
                  anon2 = AnonymousUser.create(
                              :lastname => 'Anonymous', :firstname => '',
                              :login => '', :status => 0)
                  assert_equal 1, anon2.errors.count
                end
                def test_rss_key
                  assert_nil @jsmith.rss_token
                  key = @jsmith.rss_key
                  assert_equal 40, key.length
                  @jsmith.reload
                  assert_equal key, @jsmith.rss_key
                end
                def test_rss_key_should_not_be_generated_twice
                  assert_difference 'Token.count', 1 do
                    key1 = @jsmith.rss_key
                    key2 = @jsmith.rss_key
                    assert_equal key1, key2
                  end
                end
                def test_api_key_should_not_be_generated_twice
                  assert_difference 'Token.count', 1 do
                    key1 = @jsmith.api_key
                    key2 = @jsmith.api_key
                    assert_equal key1, key2
                  end
                end
                test "#api_key should generate a new one if the user doesn't have one" do
                  user = User.generate!(:api_token => nil)
                  assert_nil user.api_token
                  key = user.api_key
                  assert_equal 40, key.length
                  user.reload
                  assert_equal key, user.api_key
                end
                test "#api_key should return the existing api token value" do
                  user = User.generate!
                  token = Token.create!(:action => 'api')
                  user.api_token = token
                  assert user.save
                  assert_equal token.value, user.api_key
                end
                test "#find_by_api_key should return nil if no matching key is found" do
                  assert_nil User.find_by_api_key('zzzzzzzzz')
                end
                test "#find_by_api_key should return nil if the key is found for an inactive user" do
                  user = User.generate!
                  user.status = User::STATUS_LOCKED
                  token = Token.create!(:action => 'api')
                  user.api_token = token
                  user.save
                  assert_nil User.find_by_api_key(token.value)
                end
                test "#find_by_api_key should return the user if the key is found for an active user" do
                  user = User.generate!
                  token = Token.create!(:action => 'api')
                  user.api_token = token
                  user.save
                  assert_equal user, User.find_by_api_key(token.value)
                end
                def test_default_admin_account_changed_should_return_false_if_account_was_not_changed
                  user = User.find_by_login("admin")
                  user.password = "admin"
                  assert user.save(:validate => false)
                  assert_equal false, User.default_admin_account_changed?
                end
                def test_default_admin_account_changed_should_return_true_if_password_was_changed
                  user = User.find_by_login("admin")
                  user.password = "newpassword"
                  user.save!
                  assert_equal true, User.default_admin_account_changed?
                end
                def test_default_admin_account_changed_should_return_true_if_account_is_disabled
                  user = User.find_by_login("admin")
                  user.password = "admin"
                  user.status = User::STATUS_LOCKED
                  assert user.save(:validate => false)
                  assert_equal true, User.default_admin_account_changed?
                end
                def test_default_admin_account_changed_should_return_true_if_account_does_not_exist
                  user = User.find_by_login("admin")
                  user.destroy
                  assert_equal true, User.default_admin_account_changed?
                end
                def test_membership_with_project_should_return_membership
                  project = Project.find(1)
                  membership = @jsmith.membership(project)
                  assert_kind_of Member, membership
                  assert_equal @jsmith, membership.user
                  assert_equal project, membership.project
                end
                def test_membership_with_project_id_should_return_membership
                  project = Project.find(1)
                  membership = @jsmith.membership(1)
                  assert_kind_of Member, membership
                  assert_equal @jsmith, membership.user
                  assert_equal project, membership.project
                end
                def test_membership_for_non_member_should_return_nil
                  project = Project.find(1)
                  user = User.generate!
                  membership = user.membership(1)
                  assert_nil membership
                end
                def test_roles_for_project_with_member_on_public_project_should_return_roles_and_non_member
                  roles = @jsmith.roles_for_project(Project.find(1))
                  assert_kind_of Role, roles.first
                  assert_equal ["Manager"], roles.map(&:name)
                end
                def test_roles_for_project_with_member_on_private_project_should_return_roles
                  Project.find(1).update_attribute :is_public, false
                  roles = @jsmith.roles_for_project(Project.find(1))
                  assert_kind_of Role, roles.first
                  assert_equal ["Manager"], roles.map(&:name)
                end
                def test_roles_for_project_with_non_member_with_public_project_should_return_non_member
                  set_language_if_valid 'en'
                  roles = User.find(8).roles_for_project(Project.find(1))
                  assert_equal ["Non member"], roles.map(&:name)
                end
                def test_roles_for_project_with_non_member_with_public_project_and_override_should_return_override_roles
                  project = Project.find(1)
                  Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
                  roles = User.find(8).roles_for_project(project)
                  assert_equal ["Developer", "Manager"], roles.map(&:name).sort
                end
                def test_roles_for_project_with_non_member_with_private_project_should_return_no_roles
                  Project.find(1).update_attribute :is_public, false
                  roles = User.find(8).roles_for_project(Project.find(1))
                  assert_equal [], roles.map(&:name)
                end
                def test_roles_for_project_with_non_member_with_private_project_and_override_should_return_no_roles
                  project = Project.find(1)
                  project.update_attribute :is_public, false
                  Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
                  roles = User.find(8).roles_for_project(project)
                  assert_equal [], roles.map(&:name).sort
                end
                def test_roles_for_project_with_anonymous_with_public_project_should_return_anonymous
                  set_language_if_valid 'en'
                  roles = User.anonymous.roles_for_project(Project.find(1))
                  assert_equal ["Anonymous"], roles.map(&:name)
                end
                def test_roles_for_project_with_anonymous_with_public_project_and_override_should_return_override_roles
                  project = Project.find(1)
                  Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
                  roles = User.anonymous.roles_for_project(project)
                  assert_equal ["Developer", "Manager"], roles.map(&:name).sort
                end
                def test_roles_for_project_with_anonymous_with_private_project_should_return_no_roles
                  Project.find(1).update_attribute :is_public, false
                  roles = User.anonymous.roles_for_project(Project.find(1))
                  assert_equal [], roles.map(&:name)
                end
                def test_roles_for_project_with_anonymous_with_private_project_and_override_should_return_no_roles
                  project = Project.find(1)
                  project.update_attribute :is_public, false
                  Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
                  roles = User.anonymous.roles_for_project(project)
                  assert_equal [], roles.map(&:name).sort
                end
                def test_roles_for_project_should_be_unique
                  m = Member.new(:user_id => 1, :project_id => 1)
                  m.member_roles.build(:role_id => 1)
                  m.member_roles.build(:role_id => 1)
                  m.save!
                  user = User.find(1)
                  project = Project.find(1)
                  assert_equal 1, user.roles_for_project(project).size
                  assert_equal [1], user.roles_for_project(project).map(&:id)
                end
                def test_projects_by_role_for_user_with_role
                  user = User.find(2)
                  assert_kind_of Hash, user.projects_by_role
                  assert_equal 2, user.projects_by_role.size
                  assert_equal [1,5], user.projects_by_role[Role.find(1)].collect(&:id).sort
                  assert_equal [2], user.projects_by_role[Role.find(2)].collect(&:id).sort
                end
                def test_accessing_projects_by_role_with_no_projects_should_return_an_empty_array
                  user = User.find(2)
                  assert_equal [], user.projects_by_role[Role.find(3)]
                  # should not update the hash
                  assert_nil user.projects_by_role.values.detect(&:blank?)
                end
                def test_projects_by_role_for_user_with_no_role
                  user = User.generate!
                  assert_equal({}, user.projects_by_role)
                end
                def test_projects_by_role_for_anonymous
                  assert_equal({}, User.anonymous.projects_by_role)
                end
                def test_valid_notification_options
                  # without memberships
                  assert_equal 5, User.find(7).valid_notification_options.size
                  # with memberships
                  assert_equal 6, User.find(2).valid_notification_options.size
                end
                def test_valid_notification_options_class_method
                  assert_equal 5, User.valid_notification_options.size
                  assert_equal 5, User.valid_notification_options(User.find(7)).size
                  assert_equal 6, User.valid_notification_options(User.find(2)).size
                end
                def test_notified_project_ids_setter_should_coerce_to_unique_integer_array
                  @jsmith.notified_project_ids = ["1", "123", "2u", "wrong", "12", 6, 12, -35, ""]
                  assert_equal [1, 123, 2, 12, 6], @jsmith.notified_projects_ids
                end
                def test_mail_notification_all
                  @jsmith.mail_notification = 'all'
                  @jsmith.notified_project_ids = []
                  @jsmith.save
                  @jsmith.reload
                  assert @jsmith.projects.first.recipients.include?(@jsmith.mail)
                end
                def test_mail_notification_selected
                  @jsmith.mail_notification = 'selected'
                  @jsmith.notified_project_ids = [1]
                  @jsmith.save
                  @jsmith.reload
                  assert Project.find(1).recipients.include?(@jsmith.mail)
                end
                def test_mail_notification_only_my_events
                  @jsmith.mail_notification = 'only_my_events'
                  @jsmith.notified_project_ids = []
                  @jsmith.save
                  @jsmith.reload
                  assert !@jsmith.projects.first.recipients.include?(@jsmith.mail)
                end
                def test_comments_sorting_preference
                  assert !@jsmith.wants_comments_in_reverse_order?
                  @jsmith.pref.comments_sorting = 'asc'
                  assert !@jsmith.wants_comments_in_reverse_order?
                  @jsmith.pref.comments_sorting = 'desc'
                  assert @jsmith.wants_comments_in_reverse_order?
                end
                def test_find_by_mail_should_be_case_insensitive
                  u = User.find_by_mail('JSmith@somenet.foo')
                  assert_not_nil u
                  assert_equal 'jsmith@somenet.foo', u.mail
                end
                def test_random_password
                  u = User.new
                  u.random_password
                  assert !u.password.blank?
                  assert !u.password_confirmation.blank?
                end
                test "#change_password_allowed? should be allowed if no auth source is set" do
                  user = User.generate!
                  assert user.change_password_allowed?
                end
                test "#change_password_allowed? should delegate to the auth source" do
                  user = User.generate!
                  allowed_auth_source = AuthSource.generate!
                  def allowed_auth_source.allow_password_changes?; true; end
                  denied_auth_source = AuthSource.generate!
                  def denied_auth_source.allow_password_changes?; false; end
                  assert user.change_password_allowed?
                  user.auth_source = allowed_auth_source
                  assert user.change_password_allowed?, "User not allowed to change password, though auth source does"
                  user.auth_source = denied_auth_source
                  assert !user.change_password_allowed?, "User allowed to change password, though auth source does not"
                end
                def test_own_account_deletable_should_be_true_with_unsubscrive_enabled
                  with_settings :unsubscribe => '1' do
                    assert_equal true, User.find(2).own_account_deletable?
                  end
                end
                def test_own_account_deletable_should_be_false_with_unsubscrive_disabled
                  with_settings :unsubscribe => '0' do
                    assert_equal false, User.find(2).own_account_deletable?
                  end
                end
                def test_own_account_deletable_should_be_false_for_a_single_admin
-                 User.delete_all(["admin = ? AND id <> ?", true, 1])
+                 User.where(["admin = ? AND id <> ?", true, 1]).delete_all
                  with_settings :unsubscribe => '1' do
                    assert_equal false, User.find(1).own_account_deletable?
                  end
                end
                def test_own_account_deletable_should_be_true_for_an_admin_if_other_admin_exists
                  User.generate! do |user|
                    user.admin = true
                  end
                  with_settings :unsubscribe => '1' do
                    assert_equal true, User.find(1).own_account_deletable?
                  end
                end
                test "#allowed_to? for archived project should return false" do
                  project = Project.find(1)
                  project.archive
                  project.reload
                  assert_equal false, @admin.allowed_to?(:view_issues, project)
                end
                test "#allowed_to? for closed project should return true for read actions" do
                  project = Project.find(1)
                  project.close
                  project.reload
                  assert_equal false, @admin.allowed_to?(:edit_project, project)
                  assert_equal true, @admin.allowed_to?(:view_project, project)
                end
                test "#allowed_to? for project with module disabled should return false" do
                  project = Project.find(1)
                  project.enabled_module_names = ["issue_tracking"]
                  assert_equal true, @admin.allowed_to?(:add_issues, project)
                  assert_equal false, @admin.allowed_to?(:view_wiki_pages, project)
                end
                test "#allowed_to? for admin users should return true" do
                  project = Project.find(1)
                  assert ! @admin.member_of?(project)
                  %w(edit_issues delete_issues manage_news add_documents manage_wiki).each do |p|
                    assert_equal true, @admin.allowed_to?(p.to_sym, project)
                  end
                end
                test "#allowed_to? for normal users" do
                  project = Project.find(1)
                  assert_equal true, @jsmith.allowed_to?(:delete_messages, project)    #Manager
                  assert_equal false, @dlopper.allowed_to?(:delete_messages, project) #Developper
                end
                test "#allowed_to? with empty array should return false" do
                  assert_equal false, @admin.allowed_to?(:view_project, [])
                end
                test "#allowed_to? with multiple projects" do
                  assert_equal true, @admin.allowed_to?(:view_project, Project.all.to_a)
                  assert_equal false, @dlopper.allowed_to?(:view_project, Project.all.to_a) #cannot see Project(2)
                  assert_equal true, @jsmith.allowed_to?(:edit_issues, @jsmith.projects.to_a) #Manager or Developer everywhere
                  assert_equal false, @jsmith.allowed_to?(:delete_issue_watchers, @jsmith.projects.to_a) #Dev cannot delete_issue_watchers
                end
                test "#allowed_to? with with options[:global] should return true if user has one role with the permission" do
                  @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
                  @anonymous = User.find(6)
                  assert_equal true, @jsmith.allowed_to?(:delete_issue_watchers, nil, :global => true)
                  assert_equal false, @dlopper2.allowed_to?(:delete_issue_watchers, nil, :global => true)
                  assert_equal true, @dlopper2.allowed_to?(:add_issues, nil, :global => true)
                  assert_equal false, @anonymous.allowed_to?(:add_issues, nil, :global => true)
                  assert_equal true, @anonymous.allowed_to?(:view_issues, nil, :global => true)
                end
                # this is just a proxy method, the test only calls it to ensure it doesn't break trivially
                test "#allowed_to_globally?" do
                  @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
                  @anonymous = User.find(6)
                  assert_equal true, @jsmith.allowed_to_globally?(:delete_issue_watchers)
                  assert_equal false, @dlopper2.allowed_to_globally?(:delete_issue_watchers)
                  assert_equal true, @dlopper2.allowed_to_globally?(:add_issues)
                  assert_equal false, @anonymous.allowed_to_globally?(:add_issues)
                  assert_equal true, @anonymous.allowed_to_globally?(:view_issues)
                end
                def test_notify_about_issue
                  project = Project.find(1)
                  author = User.generate!
                  assignee = User.generate!
                  member = User.generate!
                  Member.create!(:user => member, :project => project, :role_ids => [1])
                  issue = Issue.generate!(:project => project, :assigned_to => assignee, :author => author)
                  tests = {
                    author => %w(all only_my_events only_owner selected),
                    assignee => %w(all only_my_events only_assigned selected),
                    member => %w(all)
                  }
                  tests.each do |user, expected|
                    User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
                      user.mail_notification = option
                      assert_equal expected.include?(option), user.notify_about?(issue)
                    end
                  end
                end
                def test_notify_about_issue_for_previous_assignee
                  assignee = User.generate!(:mail_notification => 'only_assigned')
                  new_assignee = User.generate!(:mail_notification => 'only_assigned')
                  issue = Issue.generate!(:assigned_to => assignee)
                  assert assignee.notify_about?(issue)
                  assert !new_assignee.notify_about?(issue)
                  issue.assigned_to = new_assignee
                  assert assignee.notify_about?(issue)
                  assert new_assignee.notify_about?(issue)
                  issue.save!
                  assert !assignee.notify_about?(issue)
                  assert new_assignee.notify_about?(issue)
                end
                def test_notify_about_news
                  user = User.generate!
                  news = News.new
                  User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
                    user.mail_notification = option
                    assert_equal (option != 'none'), user.notify_about?(news)
                  end
                end
                def test_salt_unsalted_passwords
                  # Restore a user with an unsalted password
                  user = User.find(1)
                  user.salt = nil
                  user.hashed_password = User.hash_password("unsalted")
                  user.save!
                  User.salt_unsalted_passwords!
                  user.reload
                  # Salt added
                  assert !user.salt.blank?
                  # Password still valid
                  assert user.check_password?("unsalted")
                  assert_equal user, User.try_to_login(user.login, "unsalted")
                end
                if Object.const_defined?(:OpenID)
                  def test_setting_identity_url
                    normalized_open_id_url = 'http://example.com/'
                    u = User.new( :identity_url => 'http://example.com/' )
                    assert_equal normalized_open_id_url, u.identity_url
                  end
                  def test_setting_identity_url_without_trailing_slash
                    normalized_open_id_url = 'http://example.com/'
                    u = User.new( :identity_url => 'http://example.com' )
                    assert_equal normalized_open_id_url, u.identity_url
                  end
                  def test_setting_identity_url_without_protocol
                    normalized_open_id_url = 'http://example.com/'
                    u = User.new( :identity_url => 'example.com' )
                    assert_equal normalized_open_id_url, u.identity_url
                  end
                  def test_setting_blank_identity_url
                    u = User.new( :identity_url => 'example.com' )
                    u.identity_url = ''
                    assert u.identity_url.blank?
                  end
                  def test_setting_invalid_identity_url
                    u = User.new( :identity_url => 'this is not an openid url' )
                    assert u.identity_url.blank?
                  end
                else
                  puts "Skipping openid tests."
                end
              end

test/unit/watcher_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class WatcherTest < ActiveSupport::TestCase
                fixtures :projects, :users, :email_addresses, :members, :member_roles, :roles, :enabled_modules,
                         :issues, :issue_statuses, :enumerations, :trackers, :projects_trackers,
                         :boards, :messages,
                         :wikis, :wiki_pages,
                         :watchers
                def setup
                  @user = User.find(1)
                  @issue = Issue.find(1)
                end
                def test_validate
                  user = User.find(5)
                  assert !user.active?
                  watcher = Watcher.new(:user_id => user.id)
                  assert !watcher.save
                end
                def test_watch
                  assert @issue.add_watcher(@user)
                  @issue.reload
                  assert @issue.watchers.detect { |w| w.user == @user }
                end
                def test_cant_watch_twice
                  assert @issue.add_watcher(@user)
                  assert !@issue.add_watcher(@user)
                end
                def test_watched_by
                  assert @issue.add_watcher(@user)
                  @issue.reload
                  assert @issue.watched_by?(@user)
                  assert Issue.watched_by(@user).include?(@issue)
                end
                def test_watcher_users
                  watcher_users = Issue.find(2).watcher_users
                  assert_kind_of Array, watcher_users.collect{|w| w}
                  assert_kind_of User, watcher_users.first
                end
                def test_watcher_users_should_be_reloaded_after_adding_a_watcher
                  issue = Issue.find(2)
                  user = User.generate!
                  assert_difference 'issue.watcher_users.to_a.size' do
                    issue.add_watcher user
                  end
                end
                def test_watcher_users_should_not_validate_user
                  User.where(:id => 1).update_all("firstname = ''")
                  @user.reload
                  assert !@user.valid?
                  issue = Issue.new(:project => Project.find(1), :tracker_id => 1, :subject => "test", :author => User.find(2))
                  issue.watcher_users << @user
                  issue.save!
                  assert issue.watched_by?(@user)
                end
                def test_watcher_user_ids
                  assert_equal [1, 3], Issue.find(2).watcher_user_ids.sort
                end
                def test_watcher_user_ids=
                  issue = Issue.new
                  issue.watcher_user_ids = ['1', '3']
                  assert issue.watched_by?(User.find(1))
                end
                def test_watcher_user_ids_should_make_ids_uniq
                  issue = Issue.new(:project => Project.find(1), :tracker_id => 1, :subject => "test", :author => User.find(2))
                  issue.watcher_user_ids = ['1', '3', '1']
                  issue.save!
                  assert_equal 2, issue.watchers.count
                end
                def test_addable_watcher_users
                  addable_watcher_users = @issue.addable_watcher_users
                  assert_kind_of Array, addable_watcher_users
                  assert_kind_of User, addable_watcher_users.first
                end
                def test_addable_watcher_users_should_not_include_user_that_cannot_view_the_object
                  issue = Issue.new(:project => Project.find(1), :is_private => true)
                  assert_nil issue.addable_watcher_users.detect {|user| !issue.visible?(user)}
                end
                def test_any_watched_should_return_false_if_no_object_is_watched
                  objects = (0..2).map {Issue.generate!}
                  assert_equal false, Watcher.any_watched?(objects, @user)
                end
                def test_any_watched_should_return_true_if_one_object_is_watched
                  objects = (0..2).map {Issue.generate!}
                  objects.last.add_watcher(@user)
                  assert_equal true, Watcher.any_watched?(objects, @user)
                end
                def test_any_watched_should_return_false_with_no_object
                  assert_equal false, Watcher.any_watched?([], @user)
                end
                def test_recipients
                  @issue.watchers.delete_all
                  @issue.reload
                  assert @issue.watcher_recipients.empty?
                  assert @issue.add_watcher(@user)
                  @user.mail_notification = 'all'
                  @user.save!
                  @issue.reload
                  assert @issue.watcher_recipients.include?(@user.mail)
                  @user.mail_notification = 'none'
                  @user.save!
                  @issue.reload
                  assert !@issue.watcher_recipients.include?(@user.mail)
                end
                def test_unwatch
                  assert @issue.add_watcher(@user)
                  @issue.reload
                  assert_equal 1, @issue.remove_watcher(@user)
                end
                def test_prune_with_user
-                 Watcher.delete_all("user_id = 9")
+                 Watcher.where("user_id = 9").delete_all
                  user = User.find(9)
                  # public
                  Watcher.create!(:watchable => Issue.find(1), :user => user)
                  Watcher.create!(:watchable => Issue.find(2), :user => user)
                  Watcher.create!(:watchable => Message.find(1), :user => user)
                  Watcher.create!(:watchable => Wiki.find(1), :user => user)
                  Watcher.create!(:watchable => WikiPage.find(2), :user => user)
                  # private project (id: 2)
                  Member.create!(:project => Project.find(2), :principal => user, :role_ids => [1])
                  Watcher.create!(:watchable => Issue.find(4), :user => user)
                  Watcher.create!(:watchable => Message.find(7), :user => user)
                  Watcher.create!(:watchable => Wiki.find(2), :user => user)
                  Watcher.create!(:watchable => WikiPage.find(3), :user => user)
                  assert_no_difference 'Watcher.count' do
                    Watcher.prune(:user => User.find(9))
                  end
                  Member.delete_all
                  assert_difference 'Watcher.count', -4 do
                    Watcher.prune(:user => User.find(9))
                  end
                  assert Issue.find(1).watched_by?(user)
                  assert !Issue.find(4).watched_by?(user)
                end
                def test_prune_with_project
                  user = User.find(9)
                  Watcher.new(:watchable => Issue.find(4), :user => User.find(9)).save(:validate => false) # project 2
                  Watcher.new(:watchable => Issue.find(6), :user => User.find(9)).save(:validate => false) # project 5
                  assert Watcher.prune(:project => Project.find(5)) > 0
                  assert Issue.find(4).watched_by?(user)
                  assert !Issue.find(6).watched_by?(user)
                end
                def test_prune_all
                  user = User.find(9)
                  Watcher.new(:watchable => Issue.find(4), :user => User.find(9)).save(:validate => false)
                  assert Watcher.prune > 0
                  assert !Issue.find(4).watched_by?(user)
                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