jro_apps/redmine Commit - r2411:4601ed2f3aeb

Replaces Enumeration.get_values and Enumeration.default with named scopes....

Jean-Philippe Lang -

r2411:4601ed2f3aeb

parent child

Context file:

r2411:4601ed2f3aeb

Collapse all files

app/controllers/documents_controller.rb +1 -1

              # redMine - project management software
              # Copyright (C) 2006-2007  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 DocumentsController < ApplicationController
                before_filter :find_project, :only => [:index, :new]
                before_filter :find_document, :except => [:index, :new]
                before_filter :authorize
                helper :attachments
                def index
                  @sort_by = %w(category date title author).include?(params[:sort_by]) ? params[:sort_by] : 'category'
                  documents = @project.documents.find :all, :include => [:attachments, :category]
                  case @sort_by
                  when 'date'
                    @grouped = documents.group_by {|d| d.created_on.to_date }
                  when 'title'
                    @grouped = documents.group_by {|d| d.title.first.upcase}
                  when 'author'
                    @grouped = documents.select{|d| d.attachments.any?}.group_by {|d| d.attachments.last.author}
                  else
                    @grouped = documents.group_by(&:category)
                  end
                  @document = @project.documents.build
                  render :layout => false if request.xhr?
                end
                def show
                  @attachments = @document.attachments.find(:all, :order => "created_on DESC")
                end
                def new
                  @document = @project.documents.build(params[:document])
                  if request.post? and @document.save
                    attach_files(@document, params[:attachments])
                    flash[:notice] = l(:notice_successful_create)
                    Mailer.deliver_document_added(@document) if Setting.notified_events.include?('document_added')
                    redirect_to :action => 'index', :project_id => @project
                  end
                end
                def edit
-                 @categories = Enumeration::get_values('DCAT')
+                 @categories = Enumeration.document_categories
                  if request.post? and @document.update_attributes(params[:document])
                    flash[:notice] = l(:notice_successful_update)
                    redirect_to :action => 'show', :id => @document
                  end
                end
                def destroy
                  @document.destroy
                  redirect_to :controller => 'documents', :action => 'index', :project_id => @project
                end
                def add_attachment
                  attachments = attach_files(@document, params[:attachments])
                  Mailer.deliver_attachments_added(attachments) if !attachments.empty? && Setting.notified_events.include?('document_added')
                  redirect_to :action => 'show', :id => @document
                end
              private
                def find_project
                  @project = Project.find(params[:project_id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def find_document
                  @document = Document.find(params[:id])
                  @project = @document.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/enumerations_controller.rb +1 -1

              # redMine - project management software
              # Copyright (C) 2006  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 EnumerationsController < ApplicationController
                before_filter :require_admin
                def index
                  list
                  render :action => 'list'
                end
                # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
                verify :method => :post, :only => [ :destroy, :create, :update ],
                       :redirect_to => { :action => :list }
                def list
                end
                def new
                  @enumeration = Enumeration.new(:opt => params[:opt])
                end
                def create
                  @enumeration = Enumeration.new(params[:enumeration])
                  if @enumeration.save
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to :action => 'list', :opt => @enumeration.opt
                  else
                    render :action => 'new'
                  end
                end
                def edit
                  @enumeration = Enumeration.find(params[:id])
                end
                def update
                  @enumeration = Enumeration.find(params[:id])
                  if @enumeration.update_attributes(params[:enumeration])
                    flash[:notice] = l(:notice_successful_update)
                    redirect_to :action => 'list', :opt => @enumeration.opt
                  else
                    render :action => 'edit'
                  end
                end
                def move
                  @enumeration = Enumeration.find(params[:id])
                  case params[:position]
                  when 'highest'
                    @enumeration.move_to_top
                  when 'higher'
                    @enumeration.move_higher
                  when 'lower'
                    @enumeration.move_lower
                  when 'lowest'
                    @enumeration.move_to_bottom
                  end if params[:position]
                  redirect_to :action => 'index'
                end
                def destroy
                  @enumeration = Enumeration.find(params[:id])
                  if !@enumeration.in_use?
                    # No associated objects
                    @enumeration.destroy
                    redirect_to :action => 'index'
                  elsif params[:reassign_to_id]
                    if reassign_to = Enumeration.find_by_opt_and_id(@enumeration.opt, params[:reassign_to_id])
                      @enumeration.destroy(reassign_to)
                      redirect_to :action => 'index'
                    end
                  end
-                 @enumerations = Enumeration.get_values(@enumeration.opt) - [@enumeration]
+                 @enumerations = Enumeration.values(@enumeration.opt) - [@enumeration]
                #rescue
                #  flash[:error] = 'Unable to delete enumeration'
                #  redirect_to :action => 'index'
                end
              end

app/controllers/issues_controller.rb +4 -4

              # Redmine - project management software
              # Copyright (C) 2006-2008  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class IssuesController < ApplicationController
                menu_item :new_issue, :only => :new
                before_filter :find_issue, :only => [:show, :edit, :reply]
                before_filter :find_issues, :only => [:bulk_edit, :move, :destroy]
                before_filter :find_project, :only => [:new, :update_form, :preview]
                before_filter :authorize, :except => [:index, :changes, :gantt, :calendar, :preview, :update_form, :context_menu]
                before_filter :find_optional_project, :only => [:index, :changes, :gantt, :calendar]
                accept_key_auth :index, :changes
                helper :journals
                helper :projects
                include ProjectsHelper
                helper :custom_fields
                include CustomFieldsHelper
                helper :issue_relations
                include IssueRelationsHelper
                helper :watchers
                include WatchersHelper
                helper :attachments
                include AttachmentsHelper
                helper :queries
                helper :sort
                include SortHelper
                include IssuesHelper
                helper :timelog
                include Redmine::Export::PDF
                def index
                  retrieve_query
                  sort_init 'id', 'desc'
                  sort_update({'id' => "#{Issue.table_name}.id"}.merge(@query.columns.inject({}) {|h, c| h[c.name.to_s] = c.sortable; h}))
                  if @query.valid?
                    limit = per_page_option
                    respond_to do |format|
                      format.html { }
                      format.atom { }
                      format.csv  { limit = Setting.issues_export_limit.to_i }
                      format.pdf  { limit = Setting.issues_export_limit.to_i }
                    end
                    @issue_count = Issue.count(:include => [:status, :project], :conditions => @query.statement)
                    @issue_pages = Paginator.new self, @issue_count, limit, params['page']
                    @issues = Issue.find :all, :order => sort_clause,
                                         :include => [ :assigned_to, :status, :tracker, :project, :priority, :category, :fixed_version ],
                                         :conditions => @query.statement,
                                         :limit  =>  limit,
                                         :offset =>  @issue_pages.current.offset
                    respond_to do |format|
                      format.html { render :template => 'issues/index.rhtml', :layout => !request.xhr? }
                      format.atom { render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }
                      format.csv  { send_data(issues_to_csv(@issues, @project).read, :type => 'text/csv; header=present', :filename => 'export.csv') }
                      format.pdf  { send_data(issues_to_pdf(@issues, @project), :type => 'application/pdf', :filename => 'export.pdf') }
                    end
                  else
                    # Send html if the query is not valid
                    render(:template => 'issues/index.rhtml', :layout => !request.xhr?)
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def changes
                  retrieve_query
                  sort_init 'id', 'desc'
                  sort_update({'id' => "#{Issue.table_name}.id"}.merge(@query.columns.inject({}) {|h, c| h[c.name.to_s] = c.sortable; h}))
                  if @query.valid?
                    @journals = Journal.find :all, :include => [ :details, :user, {:issue => [:project, :author, :tracker, :status]} ],
                                                   :conditions => @query.statement,
                                                   :limit => 25,
                                                   :order => "#{Journal.table_name}.created_on DESC"
                  end
                  @title = (@project ? @project.name : Setting.app_title) + ": " + (@query.new_record? ? l(:label_changes_details) : @query.name)
                  render :layout => false, :content_type => 'application/atom+xml'
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def show
                  @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
                  @journals.each_with_index {|j,i| j.indice = i+1}
                  @journals.reverse! if User.current.wants_comments_in_reverse_order?
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                  @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
-                 @priorities = Enumeration::get_values('IPRI')
+                 @priorities = Enumeration.priorities
                  @time_entry = TimeEntry.new
                  respond_to do |format|
                    format.html { render :template => 'issues/show.rhtml' }
                    format.atom { render :action => 'changes', :layout => false, :content_type => 'application/atom+xml' }
                    format.pdf  { send_data(issue_to_pdf(@issue), :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf") }
                  end
                end
                # Add a new issue
                # The new issue will be created from an existing one if copy_from parameter is given
                def new
                  @issue = Issue.new
                  @issue.copy_from(params[:copy_from]) if params[:copy_from]
                  @issue.project = @project
                  # Tracker must be set before custom field values
                  @issue.tracker ||= @project.trackers.find((params[:issue] && params[:issue][:tracker_id]) || params[:tracker_id] || :first)
                  if @issue.tracker.nil?
                    flash.now[:error] = 'No tracker is associated to this project. Please check the Project settings.'
                    render :nothing => true, :layout => true
                    return
                  end
                  if params[:issue].is_a?(Hash)
                    @issue.attributes = params[:issue]
                    @issue.watcher_user_ids = params[:issue]['watcher_user_ids'] if User.current.allowed_to?(:add_issue_watchers, @project)
                  end
                  @issue.author = User.current
                  default_status = IssueStatus.default
                  unless default_status
                    flash.now[:error] = 'No default issue status is defined. Please check your configuration (Go to "Administration -> Issue statuses").'
                    render :nothing => true, :layout => true
                    return
                  end
                  @issue.status = default_status
                  @allowed_statuses = ([default_status] + default_status.find_new_statuses_allowed_to(User.current.role_for_project(@project), @issue.tracker)).uniq
                  if request.get? || request.xhr?
                    @issue.start_date ||= Date.today
                  else
                    requested_status = IssueStatus.find_by_id(params[:issue][:status_id])
                    # Check that the user is allowed to apply the requested status
                    @issue.status = (@allowed_statuses.include? requested_status) ? requested_status : default_status
                    if @issue.save
                      attach_files(@issue, params[:attachments])
                      flash[:notice] = l(:notice_successful_create)
                      Mailer.deliver_issue_add(@issue) if Setting.notified_events.include?('issue_added')
                      call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})
                      redirect_to(params[:continue] ? { :action => 'new', :tracker_id => @issue.tracker } :
                                                      { :action => 'show', :id => @issue })
                      return
                    end
                  end
-                 @priorities = Enumeration::get_values('IPRI')
+                 @priorities = Enumeration.priorities
                  render :layout => !request.xhr?
                end
                # Attributes that can be updated on workflow transition (without :edit permission)
                # TODO: make it configurable (at least per role)
                UPDATABLE_ATTRS_ON_TRANSITION = %w(status_id assigned_to_id fixed_version_id done_ratio) unless const_defined?(:UPDATABLE_ATTRS_ON_TRANSITION)
                def edit
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
-                 @priorities = Enumeration::get_values('IPRI')
+                 @priorities = Enumeration.priorities
                  @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                  @time_entry = TimeEntry.new
                  @notes = params[:notes]
                  journal = @issue.init_journal(User.current, @notes)
                  # User can change issue attributes only if he has :edit permission or if a workflow transition is allowed
                  if (@edit_allowed || !@allowed_statuses.empty?) && params[:issue]
                    attrs = params[:issue].dup
                    attrs.delete_if {|k,v| !UPDATABLE_ATTRS_ON_TRANSITION.include?(k) } unless @edit_allowed
                    attrs.delete(:status_id) unless @allowed_statuses.detect {|s| s.id.to_s == attrs[:status_id].to_s}
                    @issue.attributes = attrs
                  end
                  if request.post?
                    @time_entry = TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => Date.today)
                    @time_entry.attributes = params[:time_entry]
                    attachments = attach_files(@issue, params[:attachments])
                    attachments.each {|a| journal.details << JournalDetail.new(:property => 'attachment', :prop_key => a.id, :value => a.filename)}
                    call_hook(:controller_issues_edit_before_save, { :params => params, :issue => @issue, :time_entry => @time_entry, :journal => journal})
                    if (@time_entry.hours.nil? || @time_entry.valid?) && @issue.save
                      # Log spend time
                      if User.current.allowed_to?(:log_time, @project)
                        @time_entry.save
                      end
                      if !journal.new_record?
                        # Only send notification if something was actually changed
                        flash[:notice] = l(:notice_successful_update)
                        Mailer.deliver_issue_edit(journal) if Setting.notified_events.include?('issue_updated')
                      end
                      call_hook(:controller_issues_edit_after_save, { :params => params, :issue => @issue, :time_entry => @time_entry, :journal => journal})
                      redirect_to(params[:back_to] || {:action => 'show', :id => @issue})
                    end
                  end
                rescue ActiveRecord::StaleObjectError
                  # Optimistic locking exception
                  flash.now[:error] = l(:notice_locking_conflict)
                end
                def reply
                  journal = Journal.find(params[:journal_id]) if params[:journal_id]
                  if journal
                    user = journal.user
                    text = journal.notes
                  else
                    user = @issue.author
                    text = @issue.description
                  end
                  content = "#{ll(Setting.default_language, :text_user_wrote, user)}\\n> "
                  content << text.to_s.strip.gsub(%r{<pre>((.|\s)*?)</pre>}m, '[...]').gsub('"', '\"').gsub(/(\r?\n|\r\n?)/, "\\n> ") + "\\n\\n"
                  render(:update) { |page|
                    page.<< "$('notes').value = \"#{content}\";"
                    page.show 'update'
                    page << "Form.Element.focus('notes');"
                    page << "Element.scrollTo('update');"
                    page << "$('notes').scrollTop = $('notes').scrollHeight - $('notes').clientHeight;"
                  }
                end
                # Bulk edit a set of issues
                def bulk_edit
                  if request.post?
                    status = params[:status_id].blank? ? nil : IssueStatus.find_by_id(params[:status_id])
                    priority = params[:priority_id].blank? ? nil : Enumeration.find_by_id(params[:priority_id])
                    assigned_to = (params[:assigned_to_id].blank? || params[:assigned_to_id] == 'none') ? nil : User.find_by_id(params[:assigned_to_id])
                    category = (params[:category_id].blank? || params[:category_id] == 'none') ? nil : @project.issue_categories.find_by_id(params[:category_id])
                    fixed_version = (params[:fixed_version_id].blank? || params[:fixed_version_id] == 'none') ? nil : @project.versions.find_by_id(params[:fixed_version_id])
                    custom_field_values = params[:custom_field_values] ? params[:custom_field_values].reject {|k,v| v.blank?} : nil
                    unsaved_issue_ids = []
                    @issues.each do |issue|
                      journal = issue.init_journal(User.current, params[:notes])
                      issue.priority = priority if priority
                      issue.assigned_to = assigned_to if assigned_to || params[:assigned_to_id] == 'none'
                      issue.category = category if category || params[:category_id] == 'none'
                      issue.fixed_version = fixed_version if fixed_version || params[:fixed_version_id] == 'none'
                      issue.start_date = params[:start_date] unless params[:start_date].blank?
                      issue.due_date = params[:due_date] unless params[:due_date].blank?
                      issue.done_ratio = params[:done_ratio] unless params[:done_ratio].blank?
                      issue.custom_field_values = custom_field_values if custom_field_values && !custom_field_values.empty?
                      call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
                      # Don't save any change to the issue if the user is not authorized to apply the requested status
                      if (status.nil? || (issue.status.new_status_allowed_to?(status, current_role, issue.tracker) && issue.status = status)) && issue.save
                        # Send notification for each issue (if changed)
                        Mailer.deliver_issue_edit(journal) if journal.details.any? && Setting.notified_events.include?('issue_updated')
                      else
                        # Keep unsaved issue ids to display them in flash error
                        unsaved_issue_ids << issue.id
                      end
                    end
                    if unsaved_issue_ids.empty?
                      flash[:notice] = l(:notice_successful_update) unless @issues.empty?
                    else
                      flash[:error] = l(:notice_failed_to_save_issues, unsaved_issue_ids.size, @issues.size, '#' + unsaved_issue_ids.join(', #'))
                    end
                    redirect_to(params[:back_to] || {:controller => 'issues', :action => 'index', :project_id => @project})
                    return
                  end
                  # Find potential statuses the user could be allowed to switch issues to
                  @available_statuses = Workflow.find(:all, :include => :new_status,
                                                            :conditions => {:role_id => current_role.id}).collect(&:new_status).compact.uniq.sort
                  @custom_fields = @project.issue_custom_fields.select {|f| f.field_format == 'list'}
                end
                def move
                  @allowed_projects = []
                  # find projects to which the user is allowed to move the issue
                  if User.current.admin?
                    # admin is allowed to move issues to any active (visible) project
                    @allowed_projects = Project.find(:all, :conditions => Project.visible_by(User.current))
                  else
                    User.current.memberships.each {|m| @allowed_projects << m.project if m.role.allowed_to?(:move_issues)}
                  end
                  @target_project = @allowed_projects.detect {|p| p.id.to_s == params[:new_project_id]} if params[:new_project_id]
                  @target_project ||= @project
                  @trackers = @target_project.trackers
                  if request.post?
                    new_tracker = params[:new_tracker_id].blank? ? nil : @target_project.trackers.find_by_id(params[:new_tracker_id])
                    unsaved_issue_ids = []
                    @issues.each do |issue|
                      issue.init_journal(User.current)
                      unsaved_issue_ids << issue.id unless issue.move_to(@target_project, new_tracker, params[:copy_options])
                    end
                    if unsaved_issue_ids.empty?
                      flash[:notice] = l(:notice_successful_update) unless @issues.empty?
                    else
                      flash[:error] = l(:notice_failed_to_save_issues, unsaved_issue_ids.size, @issues.size, '#' + unsaved_issue_ids.join(', #'))
                    end
                    redirect_to :controller => 'issues', :action => 'index', :project_id => @project
                    return
                  end
                  render :layout => false if request.xhr?
                end
                def destroy
                  @hours = TimeEntry.sum(:hours, :conditions => ['issue_id IN (?)', @issues]).to_f
                  if @hours > 0
                    case params[:todo]
                    when 'destroy'
                      # nothing to do
                    when 'nullify'
                      TimeEntry.update_all('issue_id = NULL', ['issue_id IN (?)', @issues])
                    when 'reassign'
                      reassign_to = @project.issues.find_by_id(params[:reassign_to_id])
                      if reassign_to.nil?
                        flash.now[:error] = l(:error_issue_not_found_in_project)
                        return
                      else
                        TimeEntry.update_all("issue_id = #{reassign_to.id}", ['issue_id IN (?)', @issues])
                      end
                    else
                      # display the destroy form
                      return
                    end
                  end
                  @issues.each(&:destroy)
                  redirect_to :action => 'index', :project_id => @project
                end
                def gantt
                  @gantt = Redmine::Helpers::Gantt.new(params)
                  retrieve_query
                  if @query.valid?
                    events = []
                    # Issues that have start and due dates
                    events += Issue.find(:all,
                                         :order => "start_date, due_date",
                                         :include => [:tracker, :status, :assigned_to, :priority, :project],
                                         :conditions => ["(#{@query.statement}) AND (((start_date>=? and start_date<=?) or (due_date>=? and due_date<=?) or (start_date<? and due_date>?)) and start_date is not null and due_date is not null)", @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to]
                                         )
                    # Issues that don't have a due date but that are assigned to a version with a date
                    events += Issue.find(:all,
                                         :order => "start_date, effective_date",
                                         :include => [:tracker, :status, :assigned_to, :priority, :project, :fixed_version],
                                         :conditions => ["(#{@query.statement}) AND (((start_date>=? and start_date<=?) or (effective_date>=? and effective_date<=?) or (start_date<? and effective_date>?)) and start_date is not null and due_date is null and effective_date is not null)", @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to]
                                         )
                    # Versions
                    events += Version.find(:all, :include => :project,
                                                 :conditions => ["(#{@query.project_statement}) AND effective_date BETWEEN ? AND ?", @gantt.date_from, @gantt.date_to])
                    @gantt.events = events
                  end
                  respond_to do |format|
                    format.html { render :template => "issues/gantt.rhtml", :layout => !request.xhr? }
                    format.png  { send_data(@gantt.to_image, :disposition => 'inline', :type => 'image/png', :filename => "#{@project.nil? ? '' : "#{@project.identifier}-" }gantt.png") } if @gantt.respond_to?('to_image')
                    format.pdf  { send_data(gantt_to_pdf(@gantt, @project), :type => 'application/pdf', :filename => "#{@project.nil? ? '' : "#{@project.identifier}-" }gantt.pdf") }
                  end
                end
                def calendar
                  if params[:year] and params[:year].to_i > 1900
                    @year = params[:year].to_i
                    if params[:month] and params[:month].to_i > 0 and params[:month].to_i < 13
                      @month = params[:month].to_i
                    end
                  end
                  @year ||= Date.today.year
                  @month ||= Date.today.month
                  @calendar = Redmine::Helpers::Calendar.new(Date.civil(@year, @month, 1), current_language, :month)
                  retrieve_query
                  if @query.valid?
                    events = []
                    events += Issue.find(:all,
                                         :include => [:tracker, :status, :assigned_to, :priority, :project],
                                         :conditions => ["(#{@query.statement}) AND ((start_date BETWEEN ? AND ?) OR (due_date BETWEEN ? AND ?))", @calendar.startdt, @calendar.enddt, @calendar.startdt, @calendar.enddt]
                                         )
                    events += Version.find(:all, :include => :project,
                                                 :conditions => ["(#{@query.project_statement}) AND effective_date BETWEEN ? AND ?", @calendar.startdt, @calendar.enddt])
                    @calendar.events = events
                  end
                  render :layout => false if request.xhr?
                end
                def context_menu
                  @issues = Issue.find_all_by_id(params[:ids], :include => :project)
                  if (@issues.size == 1)
                    @issue = @issues.first
                    @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                  end
                  projects = @issues.collect(&:project).compact.uniq
                  @project = projects.first if projects.size == 1
                  @can = {:edit => (@project && User.current.allowed_to?(:edit_issues, @project)),
                          :log_time => (@project && User.current.allowed_to?(:log_time, @project)),
                          :update => (@project && (User.current.allowed_to?(:edit_issues, @project) || (User.current.allowed_to?(:change_status, @project) && @allowed_statuses && !@allowed_statuses.empty?))),
                          :move => (@project && User.current.allowed_to?(:move_issues, @project)),
                          :copy => (@issue && @project.trackers.include?(@issue.tracker) && User.current.allowed_to?(:add_issues, @project)),
                          :delete => (@project && User.current.allowed_to?(:delete_issues, @project))
                          }
                  if @project
                    @assignables = @project.assignable_users
                    @assignables << @issue.assigned_to if @issue && @issue.assigned_to && !@assignables.include?(@issue.assigned_to)
                  end
-                 @priorities = Enumeration.get_values('IPRI').reverse
+                 @priorities = Enumeration.priorities.reverse
                  @statuses = IssueStatus.find(:all, :order => 'position')
                  @back = request.env['HTTP_REFERER']
                  render :layout => false
                end
                def update_form
                  @issue = Issue.new(params[:issue])
                  render :action => :new, :layout => false
                end
                def preview
                  @issue = @project.issues.find_by_id(params[:id]) unless params[:id].blank?
                  @attachements = @issue.attachments if @issue
                  @text = params[:notes] || (params[:issue] ? params[:issue][:description] : nil)
                  render :partial => 'common/preview'
                end
              private
                def find_issue
                  @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
                  @project = @issue.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Filter for bulk operations
                def find_issues
                  @issues = Issue.find_all_by_id(params[:id] || params[:ids])
                  raise ActiveRecord::RecordNotFound if @issues.empty?
                  projects = @issues.collect(&:project).compact.uniq
                  if projects.size == 1
                    @project = projects.first
                  else
                    # TODO: let users bulk edit/move/destroy issues from different projects
                    render_error 'Can not bulk edit/move/destroy issues from different projects' and return false
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def find_project
                  @project = Project.find(params[:project_id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                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
                # Retrieve query from session or build a new query
                def retrieve_query
                  if !params[:query_id].blank?
                    cond = "project_id IS NULL"
                    cond << " OR project_id = #{@project.id}" if @project
                    @query = Query.find(params[:query_id], :conditions => cond)
                    @query.project = @project
                    session[:query] = {:id => @query.id, :project_id => @query.project_id}
                  else
                    if params[:set_filter] || session[:query].nil? || session[:query][:project_id] != (@project ? @project.id : nil)
                      # Give it a name, required to be valid
                      @query = Query.new(:name => "_")
                      @query.project = @project
                      if params[:fields] and params[:fields].is_a? Array
                        params[:fields].each do |field|
                          @query.add_filter(field, params[:operators][field], params[:values][field])
                        end
                      else
                        @query.available_filters.keys.each do |field|
                          @query.add_short_filter(field, params[field]) if params[field]
                        end
                      end
                      session[:query] = {:project_id => @query.project_id, :filters => @query.filters}
                    else
                      @query = Query.find_by_id(session[:query][:id]) if session[:query][:id]
                      @query ||= Query.new(:name => "_", :project => @project, :filters => session[:query][:filters])
                      @query.project = @project
                    end
                  end
                end
              end

app/controllers/reports_controller.rb +2 -2

              # redMine - project management software
              # Copyright (C) 2006  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 ReportsController < ApplicationController
                menu_item :issues
                before_filter :find_project, :authorize
                def issue_report
                  @statuses = IssueStatus.find(:all, :order => 'position')
                  case params[:detail]
                  when "tracker"
                    @field = "tracker_id"
                    @rows = @project.trackers
                    @data = issues_by_tracker
                    @report_title = l(:field_tracker)
                    render :template => "reports/issue_report_details"
                  when "version"
                    @field = "fixed_version_id"
                    @rows = @project.versions.sort
                    @data = issues_by_version
                    @report_title = l(:field_version)
                    render :template => "reports/issue_report_details"
                  when "priority"
                    @field = "priority_id"
-                   @rows = Enumeration::get_values('IPRI')
+                   @rows = Enumeration.priorities
                    @data = issues_by_priority
                    @report_title = l(:field_priority)
                    render :template => "reports/issue_report_details"
                  when "category"
                    @field = "category_id"
                    @rows = @project.issue_categories
                    @data = issues_by_category
                    @report_title = l(:field_category)
                    render :template => "reports/issue_report_details"
                  when "assigned_to"
                    @field = "assigned_to_id"
                    @rows = @project.members.collect { |m| m.user }
                    @data = issues_by_assigned_to
                    @report_title = l(:field_assigned_to)
                    render :template => "reports/issue_report_details"
                  when "author"
                    @field = "author_id"
                    @rows = @project.members.collect { |m| m.user }
                    @data = issues_by_author
                    @report_title = l(:field_author)
                    render :template => "reports/issue_report_details"
                  when "subproject"
                    @field = "project_id"
                    @rows = @project.descendants.active
                    @data = issues_by_subproject
                    @report_title = l(:field_subproject)
                    render :template => "reports/issue_report_details"
                  else
                    @trackers = @project.trackers
                    @versions = @project.versions.sort
-                   @priorities = Enumeration::get_values('IPRI')
+                   @priorities = Enumeration.priorities
                    @categories = @project.issue_categories
                    @assignees = @project.members.collect { |m| m.user }
                    @authors = @project.members.collect { |m| m.user }
                    @subprojects = @project.descendants.active
                    issues_by_tracker
                    issues_by_version
                    issues_by_priority
                    issues_by_category
                    issues_by_assigned_to
                    issues_by_author
                    issues_by_subproject
                    render :template => "reports/issue_report"
                  end
                end
                def delays
                  @trackers = Tracker.find(:all)
                  if request.get?
                    @selected_tracker_ids = @trackers.collect {|t| t.id.to_s }
                  else
                    @selected_tracker_ids = params[:tracker_ids].collect { |id| id.to_i.to_s } if params[:tracker_ids] and params[:tracker_ids].is_a? Array
                  end
                  @selected_tracker_ids ||= []
                  @raw =
                    ActiveRecord::Base.connection.select_all("SELECT datediff( a.created_on, b.created_on ) as delay, count(a.id) as total
                    FROM issue_histories a, issue_histories b, issues i
                    WHERE a.status_id =5
                    AND a.issue_id = b.issue_id
                    AND a.issue_id = i.id
                    AND i.tracker_id in (#{@selected_tracker_ids.join(',')})
                    AND b.id = (
                    SELECT min( c.id )
                    FROM issue_histories c
                    WHERE b.issue_id = c.issue_id )
                    GROUP BY delay") unless @selected_tracker_ids.empty?
                  @raw ||=[]
                  @x_from = 0
                  @x_to = 0
                  @y_from = 0
                  @y_to = 0
                  @sum_total = 0
                  @sum_delay = 0
                  @raw.each do |r|
                    @x_to = [r['delay'].to_i, @x_to].max
                    @y_to = [r['total'].to_i, @y_to].max
                    @sum_total = @sum_total + r['total'].to_i
                    @sum_delay = @sum_delay + r['total'].to_i * r['delay'].to_i
                  end
                end
              private
                # Find project of id params[:id]
                def find_project
                  @project = Project.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def issues_by_tracker
                  @issues_by_tracker ||=
                      ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                                s.is_closed as closed,
                                                                t.id as tracker_id,
                                                                count(i.id) as total
                                                              from
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s, #{Tracker.table_name} t
                                                              where
                                                                i.status_id=s.id
                                                                and i.tracker_id=t.id
                                                                and i.project_id=#{@project.id}
                                                              group by s.id, s.is_closed, t.id")
                end
                def issues_by_version
                  @issues_by_version ||=
                      ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                                s.is_closed as closed,
                                                                v.id as fixed_version_id,
                                                                count(i.id) as total
                                                              from
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s, #{Version.table_name} v
                                                              where
                                                                i.status_id=s.id
                                                                and i.fixed_version_id=v.id
                                                                and i.project_id=#{@project.id}
                                                              group by s.id, s.is_closed, v.id")
                end
                def issues_by_priority
                  @issues_by_priority ||=
                    ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                                s.is_closed as closed,
                                                                p.id as priority_id,
                                                                count(i.id) as total
                                                              from
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s, #{Enumeration.table_name} p
                                                              where
                                                                i.status_id=s.id
                                                                and i.priority_id=p.id
                                                                and i.project_id=#{@project.id}
                                                              group by s.id, s.is_closed, p.id")
                end
                def issues_by_category
                  @issues_by_category ||=
                    ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                                s.is_closed as closed,
                                                                c.id as category_id,
                                                                count(i.id) as total
                                                              from
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s, #{IssueCategory.table_name} c
                                                              where
                                                                i.status_id=s.id
                                                                and i.category_id=c.id
                                                                and i.project_id=#{@project.id}
                                                              group by s.id, s.is_closed, c.id")
                end
                def issues_by_assigned_to
                  @issues_by_assigned_to ||=
                    ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                                s.is_closed as closed,
                                                                a.id as assigned_to_id,
                                                                count(i.id) as total
                                                              from
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s, #{User.table_name} a
                                                              where
                                                                i.status_id=s.id
                                                                and i.assigned_to_id=a.id
                                                                and i.project_id=#{@project.id}
                                                              group by s.id, s.is_closed, a.id")
                end
                def issues_by_author
                  @issues_by_author ||=
                    ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                                s.is_closed as closed,
                                                                a.id as author_id,
                                                                count(i.id) as total
                                                              from
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s, #{User.table_name} a
                                                              where
                                                                i.status_id=s.id
                                                                and i.author_id=a.id
                                                                and i.project_id=#{@project.id}
                                                              group by s.id, s.is_closed, a.id")
                end
                def issues_by_subproject
                  @issues_by_subproject ||=
                    ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                                s.is_closed as closed,
                                                                i.project_id as project_id,
                                                                count(i.id) as total
                                                              from
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s
                                                              where
                                                                i.status_id=s.id
                                                                and i.project_id IN (#{@project.descendants.active.collect{|p| p.id}.join(',')})
                                                              group by s.id, s.is_closed, i.project_id") if @project.descendants.active.any?
                  @issues_by_subproject ||= []
                end
              end

app/helpers/timelog_helper.rb +1 -1

              # redMine - project management software
              # Copyright (C) 2006  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              module TimelogHelper
                include ApplicationHelper
                def render_timelog_breadcrumb
                  links = []
                  links << link_to(l(:label_project_all), {:project_id => nil, :issue_id => nil})
                  links << link_to(h(@project), {:project_id => @project, :issue_id => nil}) if @project
                  links << link_to_issue(@issue) if @issue
                  breadcrumb links
                end
                def activity_collection_for_select_options
-                 activities = Enumeration::get_values('ACTI')
+                 activities = Enumeration.activities
                  collection = []
                  collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ] unless activities.detect(&:is_default)
                  activities.each { |a| collection << [a.name, a.id] }
                  collection
                end
                def select_hours(data, criteria, value)
                  data.select {|row| row[criteria] == value}
                end
                def sum_hours(data)
                  sum = 0
                  data.each do |row|
                    sum += row['hours'].to_f
                  end
                  sum
                end
                def options_for_period_select(value)
                  options_for_select([[l(:label_all_time), 'all'],
                                      [l(:label_today), 'today'],
                                      [l(:label_yesterday), 'yesterday'],
                                      [l(:label_this_week), 'current_week'],
                                      [l(:label_last_week), 'last_week'],
                                      [l(:label_last_n_days, 7), '7_days'],
                                      [l(:label_this_month), 'current_month'],
                                      [l(:label_last_month), 'last_month'],
                                      [l(:label_last_n_days, 30), '30_days'],
                                      [l(:label_this_year), 'current_year']],
                                      value)
                end
                def entries_to_csv(entries)
                  ic = Iconv.new(l(:general_csv_encoding), 'UTF-8')
                  decimal_separator = l(:general_csv_decimal_separator)
                  custom_fields = TimeEntryCustomField.find(:all)
                  export = StringIO.new
                  CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
                    # csv header fields
                    headers = [l(:field_spent_on),
                               l(:field_user),
                               l(:field_activity),
                               l(:field_project),
                               l(:field_issue),
                               l(:field_tracker),
                               l(:field_subject),
                               l(:field_hours),
                               l(:field_comments)
                               ]
                    # Export custom fields
                    headers += custom_fields.collect(&:name)
                    csv << headers.collect {|c| begin; ic.iconv(c.to_s); rescue; c.to_s; end }
                    # csv lines
                    entries.each do |entry|
                      fields = [format_date(entry.spent_on),
                                entry.user,
                                entry.activity,
                                entry.project,
                                (entry.issue ? entry.issue.id : nil),
                                (entry.issue ? entry.issue.tracker : nil),
                                (entry.issue ? entry.issue.subject : nil),
                                entry.hours.to_s.gsub('.', decimal_separator),
                                entry.comments
                                ]
                      fields += custom_fields.collect {|f| show_value(entry.custom_value_for(f)) }
                      csv << fields.collect {|c| begin; ic.iconv(c.to_s); rescue; c.to_s; end }
                    end
                  end
                  export.rewind
                  export
                end
                def format_criteria_value(criteria, value)
                  value.blank? ? l(:label_none) : ((k = @available_criterias[criteria][:klass]) ? k.find_by_id(value.to_i) : format_value(value, @available_criterias[criteria][:format]))
                end
                def report_to_csv(criterias, periods, hours)
                  export = StringIO.new
                  CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
                    # Column headers
                    headers = criterias.collect {|criteria| l(@available_criterias[criteria][:label]) }
                    headers += periods
                    headers << l(:label_total)
                    csv << headers.collect {|c| to_utf8(c) }
                    # Content
                    report_criteria_to_csv(csv, criterias, periods, hours)
                    # Total row
                    row = [ l(:label_total) ] + [''] * (criterias.size - 1)
                    total = 0
                    periods.each do |period|
                      sum = sum_hours(select_hours(hours, @columns, period.to_s))
                      total += sum
                      row << (sum > 0 ? "%.2f" % sum : '')
                    end
                    row << "%.2f" %total
                    csv << row
                  end
                  export.rewind
                  export
                end
                def report_criteria_to_csv(csv, criterias, periods, hours, level=0)
                  hours.collect {|h| h[criterias[level]].to_s}.uniq.each do |value|
                    hours_for_value = select_hours(hours, criterias[level], value)
                    next if hours_for_value.empty?
                    row = [''] * level
                    row << to_utf8(format_criteria_value(criterias[level], value))
                    row += [''] * (criterias.length - level - 1)
                    total = 0
                    periods.each do |period|
                      sum = sum_hours(select_hours(hours_for_value, @columns, period.to_s))
                      total += sum
                      row << (sum > 0 ? "%.2f" % sum : '')
                    end
                    row << "%.2f" %total
                    csv << row
                    if criterias.length > level + 1
                      report_criteria_to_csv(csv, criterias, periods, hours_for_value, level + 1)
                    end
                  end
                end
                def to_utf8(s)
                  @ic ||= Iconv.new(l(:general_csv_encoding), 'UTF-8')
                  begin; @ic.iconv(s.to_s); rescue; s.to_s; end
                end
              end

app/models/document.rb +1 -1

              # redMine - project management software
              # Copyright (C) 2006  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 Document < ActiveRecord::Base
                belongs_to :project
                belongs_to :category, :class_name => "Enumeration", :foreign_key => "category_id"
                acts_as_attachable :delete_permission => :manage_documents
                acts_as_searchable :columns => ['title', "#{table_name}.description"], :include => :project
                acts_as_event :title => Proc.new {|o| "#{l(:label_document)}: #{o.title}"},
                              :author => Proc.new {|o| (a = o.attachments.find(:first, :order => "#{Attachment.table_name}.created_on ASC")) ? a.author : nil },
                              :url => Proc.new {|o| {:controller => 'documents', :action => 'show', :id => o.id}}
                acts_as_activity_provider :find_options => {:include => :project}
                validates_presence_of :project, :title, :category
                validates_length_of :title, :maximum => 60
                def after_initialize
                  if new_record?
-                   self.category ||= Enumeration.default('DCAT')
+                   self.category ||= Enumeration.document_categories.default
                  end
                end
              end

app/models/enumeration.rb +19 -7

              # redMine - project management software
              # Copyright (C) 2006  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 Enumeration < ActiveRecord::Base
                acts_as_list :scope => 'opt = \'#{opt}\''
                before_destroy :check_integrity
                validates_presence_of :opt, :name
                validates_uniqueness_of :name, :scope => [:opt]
                validates_length_of :name, :maximum => 30
                # Single table inheritance would be an option
                OPTIONS = {
-                 "IPRI" => {:label => :enumeration_issue_priorities, :model => Issue, :foreign_key => :priority_id},
-                 "DCAT" => {:label => :enumeration_doc_categories, :model => Document, :foreign_key => :category_id},
-                 "ACTI" => {:label => :enumeration_activities, :model => TimeEntry, :foreign_key => :activity_id}
+                 "IPRI" => {:label => :enumeration_issue_priorities, :model => Issue, :foreign_key => :priority_id, :scope => :priorities},
+                 "DCAT" => {:label => :enumeration_doc_categories, :model => Document, :foreign_key => :category_id, :scope => :document_categories},
+                 "ACTI" => {:label => :enumeration_activities, :model => TimeEntry, :foreign_key => :activity_id, :scope => :activities}
                }.freeze
-               def self.get_values(option)
-                 find(:all, :conditions => {:opt => option}, :order => 'position')
+               # Creates a named scope for each type of value. The scope has a +default+ method
+               # that returns the default value, or nil if no value is set as default.
+               # Example:
+               #   Enumeration.priorities
+               #   Enumeration.priorities.default
+               OPTIONS.each do |k, v|
+                 next unless v[:scope]
+                 named_scope v[:scope], :conditions => { :opt => k }, :order => 'position' do
+                   def default
+                     find(:first, :conditions => { :is_default => true })
+                   end
+                 end
                end
-               def self.default(option)
-                 find(:first, :conditions => {:opt => option, :is_default => true}, :order => 'position')
+               named_scope :values, lambda {|opt| { :conditions => { :opt => opt }, :order => 'position' } } do
+                 def default
+                   find(:first, :conditions => { :is_default => true })
+                 end
                end
                def option_name
                  OPTIONS[self.opt][:label]
                end
                def before_save
                  if is_default? && is_default_changed?
                    Enumeration.update_all("is_default = #{connection.quoted_false}", {:opt => opt})
                  end
                end
                def objects_count
                  OPTIONS[self.opt][:model].count(:conditions => "#{OPTIONS[self.opt][:foreign_key]} = #{id}")
                end
                def in_use?
                  self.objects_count != 0
                end
                alias :destroy_without_reassign :destroy
                # Destroy the enumeration
                # If a enumeration is specified, objects are reassigned
                def destroy(reassign_to = nil)
                  if reassign_to && reassign_to.is_a?(Enumeration)
                    OPTIONS[self.opt][:model].update_all("#{OPTIONS[self.opt][:foreign_key]} = #{reassign_to.id}", "#{OPTIONS[self.opt][:foreign_key]} = #{id}")
                  end
                  destroy_without_reassign
                end
                def <=>(enumeration)
                  position <=> enumeration.position
                end
                def to_s; name end
              private
                def check_integrity
                  raise "Can't delete enumeration" if self.in_use?
                end
              end

app/models/issue.rb +1 -1

              # redMine - project management software
              # Copyright (C) 2006-2007  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class Issue < ActiveRecord::Base
                belongs_to :project
                belongs_to :tracker
                belongs_to :status, :class_name => 'IssueStatus', :foreign_key => 'status_id'
                belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'
                belongs_to :assigned_to, :class_name => 'User', :foreign_key => 'assigned_to_id'
                belongs_to :fixed_version, :class_name => 'Version', :foreign_key => 'fixed_version_id'
                belongs_to :priority, :class_name => 'Enumeration', :foreign_key => 'priority_id'
                belongs_to :category, :class_name => 'IssueCategory', :foreign_key => 'category_id'
                has_many :journals, :as => :journalized, :dependent => :destroy
                has_many :time_entries, :dependent => :delete_all
                has_and_belongs_to_many :changesets, :order => "#{Changeset.table_name}.committed_on ASC, #{Changeset.table_name}.id ASC"
                has_many :relations_from, :class_name => 'IssueRelation', :foreign_key => 'issue_from_id', :dependent => :delete_all
                has_many :relations_to, :class_name => 'IssueRelation', :foreign_key => 'issue_to_id', :dependent => :delete_all
                acts_as_attachable :after_remove => :attachment_removed
                acts_as_customizable
                acts_as_watchable
                acts_as_searchable :columns => ['subject', "#{table_name}.description", "#{Journal.table_name}.notes"],
                                   :include => [:project, :journals],
                                   # sort by id so that limited eager loading doesn't break with postgresql
                                   :order_column => "#{table_name}.id"
                acts_as_event :title => Proc.new {|o| "#{o.tracker.name} ##{o.id}: #{o.subject}"},
                              :url => Proc.new {|o| {:controller => 'issues', :action => 'show', :id => o.id}},
                              :type => Proc.new {|o| 'issue' + (o.closed? ? ' closed' : '') }
                acts_as_activity_provider :find_options => {:include => [:project, :author, :tracker]},
                                          :author_key => :author_id
                validates_presence_of :subject, :priority, :project, :tracker, :author, :status
                validates_length_of :subject, :maximum => 255
                validates_inclusion_of :done_ratio, :in => 0..100
                validates_numericality_of :estimated_hours, :allow_nil => true
                named_scope :visible, lambda {|*args| { :include => :project,
                                                        :conditions => Project.allowed_to_condition(args.first || User.current, :view_issues) } }
                # Returns true if usr or current user is allowed to view the issue
                def visible?(usr=nil)
                  (usr || User.current).allowed_to?(:view_issues, self.project)
                end
                def after_initialize
                  if new_record?
                    # set default values for new records only
                    self.status ||= IssueStatus.default
-                   self.priority ||= Enumeration.default('IPRI')
+                   self.priority ||= Enumeration.priorities.default
                  end
                end
                # Overrides Redmine::Acts::Customizable::InstanceMethods#available_custom_fields
                def available_custom_fields
                  (project && tracker) ? project.all_issue_custom_fields.select {|c| tracker.custom_fields.include? c } : []
                end
                def copy_from(arg)
                  issue = arg.is_a?(Issue) ? arg : Issue.find(arg)
                  self.attributes = issue.attributes.dup
                  self.custom_values = issue.custom_values.collect {|v| v.clone}
                  self
                end
                # Moves/copies an issue to a new project and tracker
                # Returns the moved/copied issue on success, false on failure
                def move_to(new_project, new_tracker = nil, options = {})
                  options ||= {}
                  issue = options[:copy] ? self.clone : self
                  transaction do
                    if new_project && issue.project_id != new_project.id
                      # delete issue relations
                      unless Setting.cross_project_issue_relations?
                        issue.relations_from.clear
                        issue.relations_to.clear
                      end
                      # issue is moved to another project
                      # reassign to the category with same name if any
                      new_category = issue.category.nil? ? nil : new_project.issue_categories.find_by_name(issue.category.name)
                      issue.category = new_category
                      issue.fixed_version = nil
                      issue.project = new_project
                    end
                    if new_tracker
                      issue.tracker = new_tracker
                    end
                    if options[:copy]
                      issue.custom_field_values = self.custom_field_values.inject({}) {|h,v| h[v.custom_field_id] = v.value; h}
                      issue.status = self.status
                    end
                    if issue.save
                      unless options[:copy]
                        # Manually update project_id on related time entries
                        TimeEntry.update_all("project_id = #{new_project.id}", {:issue_id => id})
                      end
                    else
                      Issue.connection.rollback_db_transaction
                      return false
                    end
                  end
                  return issue
                end
                def priority_id=(pid)
                  self.priority = nil
                  write_attribute(:priority_id, pid)
                end
                def estimated_hours=(h)
                  write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h)
                end
                def validate
                  if self.due_date.nil? && @attributes['due_date'] && !@attributes['due_date'].empty?
                    errors.add :due_date, :activerecord_error_not_a_date
                  end
                  if self.due_date and self.start_date and self.due_date < self.start_date
                    errors.add :due_date, :activerecord_error_greater_than_start_date
                  end
                  if start_date && soonest_start && start_date < soonest_start
                    errors.add :start_date, :activerecord_error_invalid
                  end
                end
                def validate_on_create
                  errors.add :tracker_id, :activerecord_error_invalid unless project.trackers.include?(tracker)
                end
                def before_create
                  # default assignment based on category
                  if assigned_to.nil? && category && category.assigned_to
                    self.assigned_to = category.assigned_to
                  end
                end
                def before_save
                  if @current_journal
                    # attributes changes
                    (Issue.column_names - %w(id description)).each {|c|
                      @current_journal.details << JournalDetail.new(:property => 'attr',
                                                                    :prop_key => c,
                                                                    :old_value => @issue_before_change.send(c),
                                                                    :value => send(c)) unless send(c)==@issue_before_change.send(c)
                    }
                    # custom fields changes
                    custom_values.each {|c|
                      next if (@custom_values_before_change[c.custom_field_id]==c.value ||
                                (@custom_values_before_change[c.custom_field_id].blank? && c.value.blank?))
                      @current_journal.details << JournalDetail.new(:property => 'cf',
                                                                    :prop_key => c.custom_field_id,
                                                                    :old_value => @custom_values_before_change[c.custom_field_id],
                                                                    :value => c.value)
                    }
                    @current_journal.save
                  end
                  # Save the issue even if the journal is not saved (because empty)
                  true
                end
                def after_save
                  # Reload is needed in order to get the right status
                  reload
                  # Update start/due dates of following issues
                  relations_from.each(&:set_issue_to_dates)
                  # Close duplicates if the issue was closed
                  if @issue_before_change && !@issue_before_change.closed? && self.closed?
                    duplicates.each do |duplicate|
                      # Reload is need in case the duplicate was updated by a previous duplicate
                      duplicate.reload
                      # Don't re-close it if it's already closed
                      next if duplicate.closed?
                      # Same user and notes
                      duplicate.init_journal(@current_journal.user, @current_journal.notes)
                      duplicate.update_attribute :status, self.status
                    end
                  end
                end
                def init_journal(user, notes = "")
                  @current_journal ||= Journal.new(:journalized => self, :user => user, :notes => notes)
                  @issue_before_change = self.clone
                  @issue_before_change.status = self.status
                  @custom_values_before_change = {}
                  self.custom_values.each {|c| @custom_values_before_change.store c.custom_field_id, c.value }
                  # Make sure updated_on is updated when adding a note.
                  updated_on_will_change!
                  @current_journal
                end
                # Return true if the issue is closed, otherwise false
                def closed?
                  self.status.is_closed?
                end
                # Returns true if the issue is overdue
                def overdue?
                  !due_date.nil? && (due_date < Date.today) && !status.is_closed?
                end
                # Users the issue can be assigned to
                def assignable_users
                  project.assignable_users
                end
                # Returns an array of status that user is able to apply
                def new_statuses_allowed_to(user)
                  statuses = status.find_new_statuses_allowed_to(user.role_for_project(project), tracker)
                  statuses << status unless statuses.empty?
                  statuses.uniq.sort
                end
                # Returns the mail adresses of users that should be notified for the issue
                def recipients
                  recipients = project.recipients
                  # Author and assignee are always notified unless they have been locked
                  recipients << author.mail if author && author.active?
                  recipients << assigned_to.mail if assigned_to && assigned_to.active?
                  recipients.compact.uniq
                end
                def spent_hours
                  @spent_hours ||= time_entries.sum(:hours) || 0
                end
                def relations
                  (relations_from + relations_to).sort
                end
                def all_dependent_issues
                  dependencies = []
                  relations_from.each do |relation|
                    dependencies << relation.issue_to
                    dependencies += relation.issue_to.all_dependent_issues
                  end
                  dependencies
                end
                # Returns an array of issues that duplicate this one
                def duplicates
                  relations_to.select {|r| r.relation_type == IssueRelation::TYPE_DUPLICATES}.collect {|r| r.issue_from}
                end
                # Returns the due date or the target due date if any
                # Used on gantt chart
                def due_before
                  due_date || (fixed_version ? fixed_version.effective_date : nil)
                end
                def duration
                  (start_date && due_date) ? due_date - start_date : 0
                end
                def soonest_start
                  @soonest_start ||= relations_to.collect{|relation| relation.successor_soonest_start}.compact.min
                end
                def to_s
                  "#{tracker} ##{id}: #{subject}"
                end
                private
                # Callback on attachment deletion
                def attachment_removed(obj)
                  journal = init_journal(User.current)
                  journal.details << JournalDetail.new(:property => 'attachment',
                                                       :prop_key => obj.id,
                                                       :old_value => obj.filename)
                  journal.save
                end
              end

app/models/time_entry.rb +1 -1

              # redMine - project management software
              # Copyright (C) 2006-2008  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 TimeEntry < ActiveRecord::Base
                # could have used polymorphic association
                # project association here allows easy loading of time entries at project level with one database trip
                belongs_to :project
                belongs_to :issue
                belongs_to :user
                belongs_to :activity, :class_name => 'Enumeration', :foreign_key => :activity_id
                attr_protected :project_id, :user_id, :tyear, :tmonth, :tweek
                acts_as_customizable
                acts_as_event :title => Proc.new {|o| "#{o.user}: #{lwr(:label_f_hour, o.hours)} (#{(o.issue || o.project).event_title})"},
                              :url => Proc.new {|o| {:controller => 'timelog', :action => 'details', :project_id => o.project}},
                              :author => :user,
                              :description => :comments
                validates_presence_of :user_id, :activity_id, :project_id, :hours, :spent_on
                validates_numericality_of :hours, :allow_nil => true, :message => :activerecord_error_invalid
                validates_length_of :comments, :maximum => 255, :allow_nil => true
                def after_initialize
                  if new_record? && self.activity.nil?
-                   if default_activity = Enumeration.default('ACTI')
+                   if default_activity = Enumeration.activities.default
                      self.activity_id = default_activity.id
                    end
                  end
                end
                def before_validation
                  self.project = issue.project if issue && project.nil?
                end
                def validate
                  errors.add :hours, :activerecord_error_invalid if hours && (hours < 0 || hours >= 1000)
                  errors.add :project_id, :activerecord_error_invalid if project.nil?
                  errors.add :issue_id, :activerecord_error_invalid if (issue_id && !issue) || (issue && project!=issue.project)
                end
                def hours=(h)
                  write_attribute :hours, (h.is_a?(String) ? (h.to_hours || h) : h)
                end
                # tyear, tmonth, tweek assigned where setting spent_on attributes
                # these attributes make time aggregations easier
                def spent_on=(date)
                  super
                  self.tyear = spent_on ? spent_on.year : nil
                  self.tmonth = spent_on ? spent_on.month : nil
                  self.tweek = spent_on ? Date.civil(spent_on.year, spent_on.month, spent_on.day).cweek : nil
                end
                # Returns true if the time entry can be edited by usr, otherwise false
                def editable_by?(usr)
                  (usr == user && usr.allowed_to?(:edit_own_time_entries, project)) || usr.allowed_to?(:edit_time_entries, project)
                end
                def self.visible_by(usr)
                  with_scope(:find => { :conditions => Project.allowed_to_condition(usr, :view_time_entries) }) do
                    yield
                  end
                end
              end

app/views/documents/_form.rhtml +1 -1

              <%= error_messages_for 'document' %>
              <div class="box">
              <!--[form:document]-->
              <p><label for="document_category_id"><%=l(:field_category)%></label>
-             <%= select('document', 'category_id', Enumeration.get_values('DCAT').collect {|c| [c.name, c.id]}) %></p>
+             <%= select('document', 'category_id', Enumeration.document_categories.collect {|c| [c.name, c.id]}) %></p>
              <p><label for="document_title"><%=l(:field_title)%> <span class="required">*</span></label>
              <%= text_field 'document', 'title', :size => 60 %></p>
              <p><label for="document_description"><%=l(:field_description)%></label>
              <%= text_area 'document', 'description', :cols => 60, :rows => 15, :class => 'wiki-edit' %></p>
              <!--[eoform:document]-->
              </div>
              <%= wikitoolbar_for 'document_description' %>

app/views/enumerations/list.rhtml +1 -1

              <h2><%=l(:label_enumerations)%></h2>
              <% Enumeration::OPTIONS.each do |option, params| %>
              <h3><%= l(params[:label]) %></h3>
-             <% enumerations = Enumeration.get_values(option) %>
+             <% enumerations = Enumeration.values(option) %>
              <% if enumerations.any? %>
              <table class="list">
              <% enumerations.each do |enumeration| %>
              <tr class="<%= cycle('odd', 'even') %>">
                  <td><%= link_to h(enumeration), :action => 'edit', :id => enumeration %></td>
                  <td style="width:15%;"><%= image_tag('true.png') if enumeration.is_default? %></td>
                  <td style="width:15%;">
                  <%= link_to image_tag('2uparrow.png', :alt => l(:label_sort_highest)), {:action => 'move', :id => enumeration, :position => 'highest'}, :method => :post, :title => l(:label_sort_highest) %>
                  <%= link_to image_tag('1uparrow.png', :alt => l(:label_sort_higher)), {:action => 'move', :id => enumeration, :position => 'higher'}, :method => :post, :title => l(:label_sort_higher) %> -
                  <%= link_to image_tag('1downarrow.png', :alt => l(:label_sort_lower)), {:action => 'move', :id => enumeration, :position => 'lower'}, :method => :post, :title => l(:label_sort_lower) %>
                  <%= link_to image_tag('2downarrow.png', :alt => l(:label_sort_lowest)), {:action => 'move', :id => enumeration, :position => 'lowest'}, :method => :post, :title => l(:label_sort_lowest) %>
                  </td>
                  <td align="center" style="width:10%;">
                  <%= link_to l(:button_delete), { :action => 'destroy', :id => enumeration }, :method => :post, :confirm => l(:text_are_you_sure), :class => "icon icon-del" %>
                  </td>
              </tr>
              <% end %>
              </table>
              <% reset_cycle %>
              <% end %>
              <p><%= link_to l(:label_enumeration_new), { :action => 'new', :opt => option } %></p>
              <% end %>
              <% html_title(l(:label_enumerations)) -%>

app/views/issues/bulk_edit.rhtml +1 -1

              <h2><%= l(:label_bulk_edit_selected_issues) %></h2>
              <ul><%= @issues.collect {|i| content_tag('li', link_to(h("#{i.tracker} ##{i.id}"), { :action => 'show', :id => i }) + h(": #{i.subject}")) }.join("\n") %></ul>
              <% form_tag() do %>
              <%= @issues.collect {|i| hidden_field_tag('ids[]', i.id)}.join %>
              <div class="box">
              <fieldset>
              <legend><%= l(:label_change_properties) %></legend>
              <p>
              <% if @available_statuses.any? %>
              <label><%= l(:field_status) %>:
              <%= select_tag('status_id', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(@available_statuses, :id, :name)) %></label>
              <% end %>
              <label><%= l(:field_priority) %>:
-             <%= select_tag('priority_id', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(Enumeration.get_values('IPRI'), :id, :name)) %></label>
+             <%= select_tag('priority_id', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(Enumeration.priorities, :id, :name)) %></label>
              <label><%= l(:field_category) %>:
              <%= select_tag('category_id', content_tag('option', l(:label_no_change_option), :value => '') +
                                              content_tag('option', l(:label_none), :value => 'none') +
                                              options_from_collection_for_select(@project.issue_categories, :id, :name)) %></label>
              </p>
              <p>
              <label><%= l(:field_assigned_to) %>:
              <%= select_tag('assigned_to_id', content_tag('option', l(:label_no_change_option), :value => '') +
                                               content_tag('option', l(:label_nobody), :value => 'none') +
                                               options_from_collection_for_select(@project.assignable_users, :id, :name)) %></label>
              <label><%= l(:field_fixed_version) %>:
              <%= select_tag('fixed_version_id', content_tag('option', l(:label_no_change_option), :value => '') +
                                                 content_tag('option', l(:label_none), :value => 'none') +
                                                 options_from_collection_for_select(@project.versions.sort, :id, :name)) %></label>
              </p>
              <p>
              <label><%= l(:field_start_date) %>:
              <%= text_field_tag 'start_date', '', :size => 10 %><%= calendar_for('start_date') %></label>
              <label><%= l(:field_due_date) %>:
              <%= text_field_tag 'due_date', '', :size => 10 %><%= calendar_for('due_date') %></label>
              <label><%= l(:field_done_ratio) %>:
              <%= select_tag 'done_ratio', options_for_select([[l(:label_no_change_option), '']] + (0..10).to_a.collect {|r| ["#{r*10} %", r*10] }) %></label>
              </p>
              <% @custom_fields.each do |custom_field| %>
              <p><label><%= h(custom_field.name) %></label>
              <%= select_tag "custom_field_values[#{custom_field.id}]", options_for_select([[l(:label_no_change_option), '']] + custom_field.possible_values) %></label>
              </p>
              <% end %>
              <%= call_hook(:view_issues_bulk_edit_details_bottom, { :issues => @issues }) %>
              </fieldset>
              <fieldset><legend><%= l(:field_notes) %></legend>
              <%= text_area_tag 'notes', @notes, :cols => 60, :rows => 10, :class => 'wiki-edit' %>
              <%= wikitoolbar_for 'notes' %>
              </fieldset>
              </div>
              <p><%= submit_tag l(:button_submit) %>
              <% end %>

lib/tasks/migrate_from_mantis.rake +1 -1

              # redMine - project management software
              # Copyright (C) 2006-2007  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 'iconv'
              require 'pp'
              namespace :redmine do
              task :migrate_from_mantis => :environment do
                module MantisMigrate
                    DEFAULT_STATUS = IssueStatus.default
                    assigned_status = IssueStatus.find_by_position(2)
                    resolved_status = IssueStatus.find_by_position(3)
                    feedback_status = IssueStatus.find_by_position(4)
                    closed_status = IssueStatus.find :first, :conditions => { :is_closed => true }
                    STATUS_MAPPING = {10 => DEFAULT_STATUS,  # new
 => feedback_status, # feedback
 => DEFAULT_STATUS,  # acknowledged
 => DEFAULT_STATUS,  # confirmed
 => assigned_status, # assigned
 => resolved_status, # resolved
 => closed_status    # closed
                                      }
-                   priorities = Enumeration.get_values('IPRI')
+                   priorities = Enumeration.priorities
                    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.find(:all, :conditions => {:builtin => 0}, :order => 'position ASC')
                    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
                    set_table_name :mantis_user_table
                    def firstname
                      @firstname = realname.blank? ? username : realname.split.first[0..29]
                      @firstname.gsub!(/[^\w\s\'\-]/i, '')
                      @firstname
                    end
                    def lastname
                      @lastname = realname.blank? ? '-' : realname.split[1..-1].join(' ')[0..29]
                      @lastname.gsub!(/[^\w\s\'\-]/i, '')
                      @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
                    set_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 name
                      read_attribute(:name)[0..29]
                    end
                    def identifier
                      read_attribute(:name).underscore[0..19].gsub(/[^a-z0-9\-]/, '-')
                    end
                  end
                  class MantisVersion < ActiveRecord::Base
                    set_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
                    set_table_name :mantis_project_category_table
                  end
                  class MantisProjectUser < ActiveRecord::Base
                    set_table_name :mantis_project_user_list_table
                  end
                  class MantisBug < ActiveRecord::Base
                    set_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
                    set_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
                    set_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
                    set_table_name :mantis_bugnote_text_table
                  end
                  class MantisBugFile < ActiveRecord::Base
                    set_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
                      content
                    end
                  end
                  class MantisBugRelationship < ActiveRecord::Base
                    set_table_name :mantis_bug_relationship_table
                  end
                  class MantisBugMonitor < ActiveRecord::Base
                    set_table_name :mantis_bug_monitor_table
                  end
                  class MantisNews < ActiveRecord::Base
                    set_table_name :mantis_news_table
                  end
                  class MantisCustomField < ActiveRecord::Base
                    set_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].gsub(/[^\w\s\'\-]/, '-')
                    end
                  end
                  class MantisCustomFieldProject < ActiveRecord::Base
                    set_table_name :mantis_custom_field_project_table
                  end
                  class MantisCustomFieldString < ActiveRecord::Base
                    set_table_name :mantis_custom_field_string_table
                  end
                  def self.migrate
                    # Users
                    print "Migrating users"
                    User.delete_all "login <> 'admin'"
                    users_map = {}
                    users_migrated = 0
                    MantisUser.find(: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.find(: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
                      p.trackers << TRACKER_FEATURE
                  	print '.'
                  	# Project members
                  	project.members.each do |member|
                        m = Member.new :user => User.find_by_id(users_map[member.user_id]),
                  	                 :role => 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.to_date
                        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(:all, :order => 'id ASC').each 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.status = STATUS_MAPPING[bug.status] || DEFAULT_STATUS
                  	i.tracker = (bug.severity == 10 ? TRACKER_FEATURE : TRACKER_BUG)
                  	i.id = bug.id if keep_bug_ids
                  	next unless i.save
                  	issues_map[bug.id] = i.id
                  	print '.'
                      # 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_with_validation(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.find :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.find(: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 '.'
                    end
                    puts
                    # News
                    print "Migrating news"
                    News.destroy_all
                    MantisNews.find(:all, :conditions => 'project_id > 0').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 '.'
                    end
                    puts
                    # Custom fields
                    print "Migrating custom fields"
                    IssueCustomField.destroy_all
                    MantisCustomField.find(: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 '.'
                      # Trackers association
                      f.trackers = Tracker.find :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)
                    @ic = Iconv.new('UTF-8', charset)
                  rescue Iconv::InvalidEncoding
                    return false
                  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)
                    @ic.iconv text
                  rescue
                    text
                  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] "
                break unless STDIN.gets.match(/^y$/i)
                # Default Mantis database settings
                db_params = {:adapter => 'mysql',
                             :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]: "
                  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'
                MantisMigrate.establish_connection db_params
                MantisMigrate.migrate
              end
              end

lib/tasks/migrate_from_trac.rake +1 -1

              # redMine - project management software
              # Copyright (C) 2006-2007  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 'active_record'
              require 'iconv'
              require 'pp'
              namespace :redmine do
                desc 'Trac migration script'
                task :migrate_from_trac => :environment do
                  module TracMigrate
                      TICKET_MAP = []
                      DEFAULT_STATUS = IssueStatus.default
                      assigned_status = IssueStatus.find_by_position(2)
                      resolved_status = IssueStatus.find_by_position(3)
                      feedback_status = IssueStatus.find_by_position(4)
                      closed_status = IssueStatus.find :first, :conditions => { :is_closed => true }
                      STATUS_MAPPING = {'new' => DEFAULT_STATUS,
                                        'reopened' => feedback_status,
                                        'assigned' => assigned_status,
                                        'closed' => closed_status
                                        }
-                     priorities = Enumeration.get_values('IPRI')
+                     priorities = Enumeration.priorities
                      DEFAULT_PRIORITY = priorities[0]
                      PRIORITY_MAPPING = {'lowest' => priorities[0],
                                          'low' => priorities[0],
                                          'normal' => priorities[1],
                                          'high' => priorities[2],
                                          'highest' => priorities[3],
                                          # ---
                                          'trivial' => priorities[0],
                                          'minor' => priorities[1],
                                          'major' => priorities[2],
                                          'critical' => priorities[3],
                                          'blocker' => priorities[4]
                                          }
                      TRACKER_BUG = Tracker.find_by_position(1)
                      TRACKER_FEATURE = Tracker.find_by_position(2)
                      DEFAULT_TRACKER = TRACKER_BUG
                      TRACKER_MAPPING = {'defect' => TRACKER_BUG,
                                         'enhancement' => TRACKER_FEATURE,
                                         'task' => TRACKER_FEATURE,
                                         'patch' =>TRACKER_FEATURE
                                         }
                      roles = Role.find(:all, :conditions => {:builtin => 0}, :order => 'position ASC')
                      manager_role = roles[0]
                      developer_role = roles[1]
                      DEFAULT_ROLE = roles.last
                      ROLE_MAPPING = {'admin' => manager_role,
                                      'developer' => developer_role
                                      }
                    class ::Time
                      class << self
                        alias :real_now :now
                        def now
                          real_now - @fake_diff.to_i
                        end
                        def fake(time)
                          @fake_diff = real_now - time
                          res = yield
                          @fake_diff = 0
                         res
                        end
                      end
                    end
                    class TracComponent < ActiveRecord::Base
                      set_table_name :component
                    end
                    class TracMilestone < ActiveRecord::Base
                      set_table_name :milestone
                      # If this attribute is set a milestone has a defined target timepoint
                      def due
                        if read_attribute(:due) && read_attribute(:due) > 0
                          Time.at(read_attribute(:due)).to_date
                        else
                          nil
                        end
                      end
                      # This is the real timepoint at which the milestone has finished.
                      def completed
                        if read_attribute(:completed) && read_attribute(:completed) > 0
                          Time.at(read_attribute(:completed)).to_date
                        else
                          nil
                        end
                      end
                      def description
                        # Attribute is named descr in Trac v0.8.x
                        has_attribute?(:descr) ? read_attribute(:descr) : read_attribute(:description)
                      end
                    end
                    class TracTicketCustom < ActiveRecord::Base
                      set_table_name :ticket_custom
                    end
                    class TracAttachment < ActiveRecord::Base
                      set_table_name :attachment
                      set_inheritance_column :none
                      def time; Time.at(read_attribute(:time)) end
                      def original_filename
                        filename
                      end
                      def content_type
                        Redmine::MimeType.of(filename) || ''
                      end
                      def exist?
                        File.file? trac_fullpath
                      end
                      def read
                        File.open("#{trac_fullpath}", 'rb').read
                      end
                      def description
                        read_attribute(:description).to_s.slice(0,255)
                      end
                    private
                      def trac_fullpath
                        attachment_type = read_attribute(:type)
                        trac_file = filename.gsub( /[^a-zA-Z0-9\-_\.!~*']/n ) {|x| sprintf('%%%02x', x[0]) }
                        "#{TracMigrate.trac_attachments_directory}/#{attachment_type}/#{id}/#{trac_file}"
                      end
                    end
                    class TracTicket < ActiveRecord::Base
                      set_table_name :ticket
                      set_inheritance_column :none
                      # ticket changes: only migrate status changes and comments
                      has_many :changes, :class_name => "TracTicketChange", :foreign_key => :ticket
                      has_many :attachments, :class_name => "TracAttachment",
                                             :finder_sql => "SELECT DISTINCT attachment.* FROM #{TracMigrate::TracAttachment.table_name}" +
                                                            " WHERE #{TracMigrate::TracAttachment.table_name}.type = 'ticket'" +
                                                            ' AND #{TracMigrate::TracAttachment.table_name}.id = \'#{id}\''
                      has_many :customs, :class_name => "TracTicketCustom", :foreign_key => :ticket
                      def ticket_type
                        read_attribute(:type)
                      end
                      def summary
                        read_attribute(:summary).blank? ? "(no subject)" : read_attribute(:summary)
                      end
                      def description
                        read_attribute(:description).blank? ? summary : read_attribute(:description)
                      end
                      def time; Time.at(read_attribute(:time)) end
                      def changetime; Time.at(read_attribute(:changetime)) end
                    end
                    class TracTicketChange < ActiveRecord::Base
                      set_table_name :ticket_change
                      def time; Time.at(read_attribute(:time)) end
                    end
                    TRAC_WIKI_PAGES = %w(InterMapTxt InterTrac InterWiki RecentChanges SandBox TracAccessibility TracAdmin TracBackup TracBrowser TracCgi TracChangeset \
                                         TracEnvironment TracFastCgi TracGuide TracImport TracIni TracInstall TracInterfaceCustomization \
                                         TracLinks TracLogging TracModPython TracNotification TracPermissions TracPlugins TracQuery \
                                         TracReports TracRevisionLog TracRoadmap TracRss TracSearch TracStandalone TracSupport TracSyntaxColoring TracTickets \
                                         TracTicketsCustomFields TracTimeline TracUnicode TracUpgrade TracWiki WikiDeletePage WikiFormatting \
                                         WikiHtml WikiMacros WikiNewPage WikiPageNames WikiProcessors WikiRestructuredText WikiRestructuredTextLinks \
                                         CamelCase TitleIndex)
                    class TracWikiPage < ActiveRecord::Base
                      set_table_name :wiki
                      set_primary_key :name
                      has_many :attachments, :class_name => "TracAttachment",
                                             :finder_sql => "SELECT DISTINCT attachment.* FROM #{TracMigrate::TracAttachment.table_name}" +
                                                    " WHERE #{TracMigrate::TracAttachment.table_name}.type = 'wiki'" +
                                                    ' AND #{TracMigrate::TracAttachment.table_name}.id = \'#{id}\''
                      def self.columns
                        # Hides readonly Trac field to prevent clash with AR readonly? method (Rails 2.0)
                        super.select {|column| column.name.to_s != 'readonly'}
                      end
                      def time; Time.at(read_attribute(:time)) end
                    end
                    class TracPermission < ActiveRecord::Base
                      set_table_name :permission
                    end
                    class TracSessionAttribute < ActiveRecord::Base
                      set_table_name :session_attribute
                    end
                    def self.find_or_create_user(username, project_member = false)
                      return User.anonymous if username.blank?
                      u = User.find_by_login(username)
                      if !u
                        # Create a new user if not found
                        mail = username[0,limit_for(User, 'mail')]
                        if mail_attr = TracSessionAttribute.find_by_sid_and_name(username, 'email')
                          mail = mail_attr.value
                        end
                        mail = "#{mail}@foo.bar" unless mail.include?("@")
                        name = username
                        if name_attr = TracSessionAttribute.find_by_sid_and_name(username, 'name')
                          name = name_attr.value
                        end
                        name =~ (/(.*)(\s+\w+)?/)
                        fn = $1.strip
                        ln = ($2 || '-').strip
                        u = User.new :mail => mail.gsub(/[^-@a-z0-9\.]/i, '-'),
                                     :firstname => fn[0, limit_for(User, 'firstname')].gsub(/[^\w\s\'\-]/i, '-'),
                                     :lastname => ln[0, limit_for(User, 'lastname')].gsub(/[^\w\s\'\-]/i, '-')
                        u.login = username[0,limit_for(User, 'login')].gsub(/[^a-z0-9_\-@\.]/i, '-')
                        u.password = 'trac'
                        u.admin = true if TracPermission.find_by_username_and_action(username, 'admin')
                        # finally, a default user is used if the new user is not valid
                        u = User.find(:first) unless u.save
                      end
                      # Make sure he is a member of the project
                      if project_member && !u.member_of?(@target_project)
                        role = DEFAULT_ROLE
                        if u.admin
                          role = ROLE_MAPPING['admin']
                        elsif TracPermission.find_by_username_and_action(username, 'developer')
                          role = ROLE_MAPPING['developer']
                        end
                        Member.create(:user => u, :project => @target_project, :role => role)
                        u.reload
                      end
                      u
                    end
                    # Basic wiki syntax conversion
                    def self.convert_wiki_text(text)
                      # Titles
                      text = text.gsub(/^(\=+)\s(.+)\s(\=+)/) {|s| "\nh#{$1.length}. #{$2}\n"}
                      # External Links
                      text = text.gsub(/\[(http[^\s]+)\s+([^\]]+)\]/) {|s| "\"#{$2}\":#{$1}"}
                      # Ticket links:
                      #      [ticket:234 Text],[ticket:234 This is a test]
                      text = text.gsub(/\[ticket\:([^\ ]+)\ (.+?)\]/, '"\2":/issues/show/\1')
                      #      ticket:1234
                      #      #1 is working cause Redmine uses the same syntax.
                      text = text.gsub(/ticket\:([^\ ]+)/, '#\1')
                      # Milestone links:
                      #      [milestone:"0.1.0 Mercury" Milestone 0.1.0 (Mercury)]
                      #      The text "Milestone 0.1.0 (Mercury)" is not converted,
                      #      cause Redmine's wiki does not support this.
                      text = text.gsub(/\[milestone\:\"([^\"]+)\"\ (.+?)\]/, 'version:"\1"')
                      #      [milestone:"0.1.0 Mercury"]
                      text = text.gsub(/\[milestone\:\"([^\"]+)\"\]/, 'version:"\1"')
                      text = text.gsub(/milestone\:\"([^\"]+)\"/, 'version:"\1"')
                      #      milestone:0.1.0
                      text = text.gsub(/\[milestone\:([^\ ]+)\]/, 'version:\1')
                      text = text.gsub(/milestone\:([^\ ]+)/, 'version:\1')
                      # Internal Links
                      text = text.gsub(/\[\[BR\]\]/, "\n") # This has to go before the rules below
                      text = text.gsub(/\[\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                      text = text.gsub(/\[wiki:\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                      text = text.gsub(/\[wiki:\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                      text = text.gsub(/\[wiki:([^\s\]]+)\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                      text = text.gsub(/\[wiki:([^\s\]]+)\s(.*)\]/) {|s| "[[#{$1.delete(',./?;|:')}|#{$2.delete(',./?;|:')}]]"}
                # Links to pages UsingJustWikiCaps
                text = text.gsub(/([^!]|^)(^| )([A-Z][a-z]+[A-Z][a-zA-Z]+)/, '\\1\\2[[\3]]')
                # Normalize things that were supposed to not be links
                # like !NotALink
                text = text.gsub(/(^| )!([A-Z][A-Za-z]+)/, '\1\2')
                      # Revisions links
                      text = text.gsub(/\[(\d+)\]/, 'r\1')
                      # Ticket number re-writing
                      text = text.gsub(/#(\d+)/) do |s|
                        if $1.length < 10
                          TICKET_MAP[$1.to_i] ||= $1
                          "\##{TICKET_MAP[$1.to_i] || $1}"
                        else
                          s
                        end
                      end
                      # We would like to convert the Code highlighting too
                      # This will go into the next line.
                      shebang_line = false
                      # Reguar expression for start of code
                      pre_re = /\{\{\{/
                      # Code hightlighing...
                      shebang_re = /^\#\!([a-z]+)/
                      # Regular expression for end of code
                      pre_end_re = /\}\}\}/
                      # Go through the whole text..extract it line by line
                      text = text.gsub(/^(.*)$/) do |line|
                        m_pre = pre_re.match(line)
                        if m_pre
                          line = '<pre>'
                        else
                          m_sl = shebang_re.match(line)
                          if m_sl
                            shebang_line = true
                            line = '<code class="' + m_sl[1] + '">'
                          end
                          m_pre_end = pre_end_re.match(line)
                          if m_pre_end
                            line = '</pre>'
                            if shebang_line
                              line = '</code>' + line
                            end
                          end
                        end
                        line
                      end
                      # Highlighting
                      text = text.gsub(/'''''([^\s])/, '_*\1')
                      text = text.gsub(/([^\s])'''''/, '\1*_')
                      text = text.gsub(/'''/, '*')
                      text = text.gsub(/''/, '_')
                      text = text.gsub(/__/, '+')
                      text = text.gsub(/~~/, '-')
                      text = text.gsub(/`/, '@')
                      text = text.gsub(/,,/, '~')
                      # Lists
                      text = text.gsub(/^([ ]+)\* /) {|s| '*' * $1.length + " "}
                      text
                    end
                    def self.migrate
                      establish_connection
                      # Quick database test
                      TracComponent.count
                      migrated_components = 0
                      migrated_milestones = 0
                      migrated_tickets = 0
                      migrated_custom_values = 0
                      migrated_ticket_attachments = 0
                      migrated_wiki_edits = 0
                      migrated_wiki_attachments = 0
                      #Wiki system initializing...
                      @target_project.wiki.destroy if @target_project.wiki
                      @target_project.reload
                      wiki = Wiki.new(:project => @target_project, :start_page => 'WikiStart')
                      wiki_edit_count = 0
                      # Components
                      print "Migrating components"
                      issues_category_map = {}
                      TracComponent.find(:all).each do |component|
                      print '.'
                      STDOUT.flush
                        c = IssueCategory.new :project => @target_project,
                                              :name => encode(component.name[0, limit_for(IssueCategory, 'name')])
                      next unless c.save
                      issues_category_map[component.name] = c
                      migrated_components += 1
                      end
                      puts
                      # Milestones
                      print "Migrating milestones"
                      version_map = {}
                      TracMilestone.find(:all).each do |milestone|
                        print '.'
                        STDOUT.flush
                        # First we try to find the wiki page...
                        p = wiki.find_or_new_page(milestone.name.to_s)
                        p.content = WikiContent.new(:page => p) if p.new_record?
                        p.content.text = milestone.description.to_s
                        p.content.author = find_or_create_user('trac')
                        p.content.comments = 'Milestone'
                        p.save
                        v = Version.new :project => @target_project,
                                        :name => encode(milestone.name[0, limit_for(Version, 'name')]),
                                        :description => nil,
                                        :wiki_page_title => milestone.name.to_s,
                                        :effective_date => milestone.completed
                        next unless v.save
                        version_map[milestone.name] = v
                        migrated_milestones += 1
                      end
                      puts
                      # Custom fields
                      # TODO: read trac.ini instead
                      print "Migrating custom fields"
                      custom_field_map = {}
                      TracTicketCustom.find_by_sql("SELECT DISTINCT name FROM #{TracTicketCustom.table_name}").each do |field|
                        print '.'
                        STDOUT.flush
                        # Redmine custom field name
                        field_name = encode(field.name[0, limit_for(IssueCustomField, 'name')]).humanize
                        # Find if the custom already exists in Redmine
                        f = IssueCustomField.find_by_name(field_name)
                        # Or create a new one
                        f ||= IssueCustomField.create(:name => encode(field.name[0, limit_for(IssueCustomField, 'name')]).humanize,
                                                      :field_format => 'string')
                        next if f.new_record?
                        f.trackers = Tracker.find(:all)
                        f.projects << @target_project
                        custom_field_map[field.name] = f
                      end
                      puts
                      # Trac 'resolution' field as a Redmine custom field
                      r = IssueCustomField.find(:first, :conditions => { :name => "Resolution" })
                      r = IssueCustomField.new(:name => 'Resolution',
                                               :field_format => 'list',
                                               :is_filter => true) if r.nil?
                      r.trackers = Tracker.find(:all)
                      r.projects << @target_project
                      r.possible_values = (r.possible_values + %w(fixed invalid wontfix duplicate worksforme)).flatten.compact.uniq
                      r.save!
                      custom_field_map['resolution'] = r
                      # Tickets
                      print "Migrating tickets"
                        TracTicket.find(:all, :order => 'id ASC').each do |ticket|
                        print '.'
                        STDOUT.flush
                        i = Issue.new :project => @target_project,
                                        :subject => encode(ticket.summary[0, limit_for(Issue, 'subject')]),
                                        :description => convert_wiki_text(encode(ticket.description)),
                                        :priority => PRIORITY_MAPPING[ticket.priority] || DEFAULT_PRIORITY,
                                        :created_on => ticket.time
                        i.author = find_or_create_user(ticket.reporter)
                        i.category = issues_category_map[ticket.component] unless ticket.component.blank?
                        i.fixed_version = version_map[ticket.milestone] unless ticket.milestone.blank?
                        i.status = STATUS_MAPPING[ticket.status] || DEFAULT_STATUS
                        i.tracker = TRACKER_MAPPING[ticket.ticket_type] || DEFAULT_TRACKER
                        i.id = ticket.id unless Issue.exists?(ticket.id)
                        next unless Time.fake(ticket.changetime) { i.save }
                        TICKET_MAP[ticket.id] = i.id
                        migrated_tickets += 1
                        # Owner
                          unless ticket.owner.blank?
                            i.assigned_to = find_or_create_user(ticket.owner, true)
                            Time.fake(ticket.changetime) { i.save }
                          end
                        # Comments and status/resolution changes
                        ticket.changes.group_by(&:time).each do |time, changeset|
                            status_change = changeset.select {|change| change.field == 'status'}.first
                            resolution_change = changeset.select {|change| change.field == 'resolution'}.first
                            comment_change = changeset.select {|change| change.field == 'comment'}.first
                            n = Journal.new :notes => (comment_change ? convert_wiki_text(encode(comment_change.newvalue)) : ''),
                                            :created_on => time
                            n.user = find_or_create_user(changeset.first.author)
                            n.journalized = i
                            if status_change &&
                                 STATUS_MAPPING[status_change.oldvalue] &&
                                 STATUS_MAPPING[status_change.newvalue] &&
                                 (STATUS_MAPPING[status_change.oldvalue] != STATUS_MAPPING[status_change.newvalue])
                              n.details << JournalDetail.new(:property => 'attr',
                                                             :prop_key => 'status_id',
                                                             :old_value => STATUS_MAPPING[status_change.oldvalue].id,
                                                             :value => STATUS_MAPPING[status_change.newvalue].id)
                            end
                            if resolution_change
                              n.details << JournalDetail.new(:property => 'cf',
                                                             :prop_key => custom_field_map['resolution'].id,
                                                             :old_value => resolution_change.oldvalue,
                                                             :value => resolution_change.newvalue)
                            end
                            n.save unless n.details.empty? && n.notes.blank?
                        end
                        # Attachments
                        ticket.attachments.each do |attachment|
                          next unless attachment.exist?
                            a = Attachment.new :created_on => attachment.time
                            a.file = attachment
                            a.author = find_or_create_user(attachment.author)
                            a.container = i
                            a.description = attachment.description
                            migrated_ticket_attachments += 1 if a.save
                        end
                        # Custom fields
                        custom_values = ticket.customs.inject({}) do |h, custom|
                          if custom_field = custom_field_map[custom.name]
                            h[custom_field.id] = custom.value
                            migrated_custom_values += 1
                          end
                          h
                        end
                        if custom_field_map['resolution'] && !ticket.resolution.blank?
                          custom_values[custom_field_map['resolution'].id] = ticket.resolution
                        end
                        i.custom_field_values = custom_values
                        i.save_custom_field_values
                      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
                      # Wiki
                      print "Migrating wiki"
                      if wiki.save
                        TracWikiPage.find(:all, :order => 'name, version').each do |page|
                          # Do not migrate Trac manual wiki pages
                          next if TRAC_WIKI_PAGES.include?(page.name)
                          wiki_edit_count += 1
                          print '.'
                          STDOUT.flush
                          p = wiki.find_or_new_page(page.name)
                          p.content = WikiContent.new(:page => p) if p.new_record?
                          p.content.text = page.text
                          p.content.author = find_or_create_user(page.author) unless page.author.blank? || page.author == 'trac'
                          p.content.comments = page.comment
                          Time.fake(page.time) { p.new_record? ? p.save : p.content.save }
                          next if p.content.new_record?
                          migrated_wiki_edits += 1
                          # Attachments
                          page.attachments.each do |attachment|
                            next unless attachment.exist?
                            next if p.attachments.find_by_filename(attachment.filename.gsub(/^.*(\\|\/)/, '').gsub(/[^\w\.\-]/,'_')) #add only once per page
                            a = Attachment.new :created_on => attachment.time
                            a.file = attachment
                            a.author = find_or_create_user(attachment.author)
                            a.description = attachment.description
                            a.container = p
                            migrated_wiki_attachments += 1 if a.save
                          end
                        end
                        wiki.reload
                        wiki.pages.each do |page|
                          page.content.text = convert_wiki_text(page.content.text)
                          Time.fake(page.content.updated_on) { page.content.save }
                        end
                      end
                      puts
                      puts
                      puts "Components:      #{migrated_components}/#{TracComponent.count}"
                      puts "Milestones:      #{migrated_milestones}/#{TracMilestone.count}"
                      puts "Tickets:         #{migrated_tickets}/#{TracTicket.count}"
                      puts "Ticket files:    #{migrated_ticket_attachments}/" + TracAttachment.count(:conditions => {:type => 'ticket'}).to_s
                      puts "Custom values:   #{migrated_custom_values}/#{TracTicketCustom.count}"
                      puts "Wiki edits:      #{migrated_wiki_edits}/#{wiki_edit_count}"
                      puts "Wiki files:      #{migrated_wiki_attachments}/" + TracAttachment.count(:conditions => {:type => 'wiki'}).to_s
                    end
                    def self.limit_for(klass, attribute)
                      klass.columns_hash[attribute.to_s].limit
                    end
                    def self.encoding(charset)
                      @ic = Iconv.new('UTF-8', charset)
                    rescue Iconv::InvalidEncoding
                      puts "Invalid encoding!"
                      return false
                    end
                    def self.set_trac_directory(path)
                      @@trac_directory = path
                      raise "This directory doesn't exist!" unless File.directory?(path)
                      raise "#{trac_attachments_directory} doesn't exist!" unless File.directory?(trac_attachments_directory)
                      @@trac_directory
                    rescue Exception => e
                      puts e
                      return false
                    end
                    def self.trac_directory
                      @@trac_directory
                    end
                    def self.set_trac_adapter(adapter)
                      return false if adapter.blank?
                      raise "Unknown adapter: #{adapter}!" unless %w(sqlite sqlite3 mysql postgresql).include?(adapter)
                      # If adapter is sqlite or sqlite3, make sure that trac.db exists
                      raise "#{trac_db_path} doesn't exist!" if %w(sqlite sqlite3).include?(adapter) && !File.exist?(trac_db_path)
                      @@trac_adapter = adapter
                    rescue Exception => e
                      puts e
                      return false
                    end
                    def self.set_trac_db_host(host)
                      return nil if host.blank?
                      @@trac_db_host = host
                    end
                    def self.set_trac_db_port(port)
                      return nil if port.to_i == 0
                      @@trac_db_port = port.to_i
                    end
                    def self.set_trac_db_name(name)
                      return nil if name.blank?
                      @@trac_db_name = name
                    end
                    def self.set_trac_db_username(username)
                      @@trac_db_username = username
                    end
                    def self.set_trac_db_password(password)
                      @@trac_db_password = password
                    end
                    def self.set_trac_db_schema(schema)
                      @@trac_db_schema = schema
                    end
                    mattr_reader :trac_directory, :trac_adapter, :trac_db_host, :trac_db_port, :trac_db_name, :trac_db_schema, :trac_db_username, :trac_db_password
                    def self.trac_db_path; "#{trac_directory}/db/trac.db" end
                    def self.trac_attachments_directory; "#{trac_directory}/attachments" end
                    def self.target_project_identifier(identifier)
                      project = Project.find_by_identifier(identifier)
                      if !project
                        # create the target project
                        project = Project.new :name => identifier.humanize,
                                              :description => ''
                        project.identifier = identifier
                        puts "Unable to create a project with identifier '#{identifier}'!" unless project.save
                        # enable issues and wiki for the created project
                        project.enabled_module_names = ['issue_tracking', 'wiki']
                      else
                        puts
                        puts "This project already exists in your Redmine database."
                        print "Are you sure you want to append data to this project ? [Y/n] "
                        exit if STDIN.gets.match(/^n$/i)
                      end
                      project.trackers << TRACKER_BUG unless project.trackers.include?(TRACKER_BUG)
                      project.trackers << TRACKER_FEATURE unless project.trackers.include?(TRACKER_FEATURE)
                      @target_project = project.new_record? ? nil : project
                    end
                    def self.connection_params
                      if %w(sqlite sqlite3).include?(trac_adapter)
                        {:adapter => trac_adapter,
                         :database => trac_db_path}
                      else
                        {:adapter => trac_adapter,
                         :database => trac_db_name,
                         :host => trac_db_host,
                         :port => trac_db_port,
                         :username => trac_db_username,
                         :password => trac_db_password,
                         :schema_search_path => trac_db_schema
                        }
                      end
                    end
                    def self.establish_connection
                      constants.each do |const|
                        klass = const_get(const)
                        next unless klass.respond_to? 'establish_connection'
                        klass.establish_connection connection_params
                      end
                    end
                  private
                    def self.encode(text)
                      @ic.iconv text
                    rescue
                      text
                    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: a new project will be added to Redmine during this process."
                  print "Are you sure you want to continue ? [y/N] "
                  break unless STDIN.gets.match(/^y$/i)
                  puts
                  def prompt(text, options = {}, &block)
                    default = options[:default] || ''
                    while true
                      print "#{text} [#{default}]: "
                      value = STDIN.gets.chomp!
                      value = default if value.blank?
                      break if yield value
                    end
                  end
                  DEFAULT_PORTS = {'mysql' => 3306, 'postgresql' => 5432}
                  prompt('Trac directory') {|directory| TracMigrate.set_trac_directory directory.strip}
                  prompt('Trac database adapter (sqlite, sqlite3, mysql, postgresql)', :default => 'sqlite') {|adapter| TracMigrate.set_trac_adapter adapter}
                  unless %w(sqlite sqlite3).include?(TracMigrate.trac_adapter)
                    prompt('Trac database host', :default => 'localhost') {|host| TracMigrate.set_trac_db_host host}
                    prompt('Trac database port', :default => DEFAULT_PORTS[TracMigrate.trac_adapter]) {|port| TracMigrate.set_trac_db_port port}
                    prompt('Trac database name') {|name| TracMigrate.set_trac_db_name name}
                    prompt('Trac database schema', :default => 'public') {|schema| TracMigrate.set_trac_db_schema schema}
                    prompt('Trac database username') {|username| TracMigrate.set_trac_db_username username}
                    prompt('Trac database password') {|password| TracMigrate.set_trac_db_password password}
                  end
                  prompt('Trac database encoding', :default => 'UTF-8') {|encoding| TracMigrate.encoding encoding}
                  prompt('Target project identifier') {|identifier| TracMigrate.target_project_identifier identifier}
                  puts
                  TracMigrate.migrate
                end
              end

test/functional/issues_controller_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2008  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.dirname(__FILE__) + '/../test_helper'
              require 'issues_controller'
              # Re-raise errors caught by the controller.
              class IssuesController; def rescue_action(e) raise e end; end
              class IssuesControllerTest < Test::Unit::TestCase
                fixtures :projects,
                         :users,
                         :roles,
                         :members,
                         :issues,
                         :issue_statuses,
                         :versions,
                         :trackers,
                         :projects_trackers,
                         :issue_categories,
                         :enabled_modules,
                         :enumerations,
                         :attachments,
                         :workflows,
                         :custom_fields,
                         :custom_values,
                         :custom_fields_trackers,
                         :time_entries,
                         :journals,
                         :journal_details
                def setup
                  @controller = IssuesController.new
                  @request    = ActionController::TestRequest.new
                  @response   = ActionController::TestResponse.new
                  User.current = nil
                end
                def test_index_routing
                  assert_routing(
                    {:method => :get, :path => '/issues'},
                    :controller => 'issues', :action => 'index'
                  )
                end
                def test_index
                  get :index
                  assert_response :success
                  assert_template 'index.rhtml'
                  assert_not_nil assigns(:issues)
                  assert_nil assigns(:project)
                  assert_tag :tag => 'a', :content => /Can't print recipes/
                  assert_tag :tag => 'a', :content => /Subproject issue/
                  # private projects hidden
                  assert_no_tag :tag => 'a', :content => /Issue of a private subproject/
                  assert_no_tag :tag => 'a', :content => /Issue on project 2/
                end
                def test_index_should_not_list_issues_when_module_disabled
                  EnabledModule.delete_all("name = 'issue_tracking' AND project_id = 1")
                  get :index
                  assert_response :success
                  assert_template 'index.rhtml'
                  assert_not_nil assigns(:issues)
                  assert_nil assigns(:project)
                  assert_no_tag :tag => 'a', :content => /Can't print recipes/
                  assert_tag :tag => 'a', :content => /Subproject issue/
                end
                def test_index_with_project_routing
                  assert_routing(
                    {:method => :get, :path => '/projects/23/issues'},
                    :controller => 'issues', :action => 'index', :project_id => '23'
                  )
                end
                def test_index_should_not_list_issues_when_module_disabled
                  EnabledModule.delete_all("name = 'issue_tracking' AND project_id = 1")
                  get :index
                  assert_response :success
                  assert_template 'index.rhtml'
                  assert_not_nil assigns(:issues)
                  assert_nil assigns(:project)
                  assert_no_tag :tag => 'a', :content => /Can't print recipes/
                  assert_tag :tag => 'a', :content => /Subproject issue/
                end
                def test_index_with_project_routing
                  assert_routing(
                    {:method => :get, :path => 'projects/23/issues'},
                    :controller => 'issues', :action => 'index', :project_id => '23'
                  )
                end
                def test_index_with_project
                  Setting.display_subprojects_issues = 0
                  get :index, :project_id => 1
                  assert_response :success
                  assert_template 'index.rhtml'
                  assert_not_nil assigns(:issues)
                  assert_tag :tag => 'a', :content => /Can't print recipes/
                  assert_no_tag :tag => 'a', :content => /Subproject issue/
                end
                def test_index_with_project_and_subprojects
                  Setting.display_subprojects_issues = 1
                  get :index, :project_id => 1
                  assert_response :success
                  assert_template 'index.rhtml'
                  assert_not_nil assigns(:issues)
                  assert_tag :tag => 'a', :content => /Can't print recipes/
                  assert_tag :tag => 'a', :content => /Subproject issue/
                  assert_no_tag :tag => 'a', :content => /Issue of a private subproject/
                end
                def test_index_with_project_and_subprojects_should_show_private_subprojects
                  @request.session[:user_id] = 2
                  Setting.display_subprojects_issues = 1
                  get :index, :project_id => 1
                  assert_response :success
                  assert_template 'index.rhtml'
                  assert_not_nil assigns(:issues)
                  assert_tag :tag => 'a', :content => /Can't print recipes/
                  assert_tag :tag => 'a', :content => /Subproject issue/
                  assert_tag :tag => 'a', :content => /Issue of a private subproject/
                end
                def test_index_with_project_routing_formatted
                  assert_routing(
                    {:method => :get, :path => 'projects/23/issues.pdf'},
                    :controller => 'issues', :action => 'index', :project_id => '23', :format => 'pdf'
                  )
                  assert_routing(
                    {:method => :get, :path => 'projects/23/issues.atom'},
                    :controller => 'issues', :action => 'index', :project_id => '23', :format => 'atom'
                  )
                end
                def test_index_with_project_and_filter
                  get :index, :project_id => 1, :set_filter => 1
                  assert_response :success
                  assert_template 'index.rhtml'
                  assert_not_nil assigns(:issues)
                end
                def test_index_csv_with_project
                  get :index, :format => 'csv'
                  assert_response :success
                  assert_not_nil assigns(:issues)
                  assert_equal 'text/csv', @response.content_type
                  get :index, :project_id => 1, :format => 'csv'
                  assert_response :success
                  assert_not_nil assigns(:issues)
                  assert_equal 'text/csv', @response.content_type
                end
                def test_index_formatted
                  assert_routing(
                    {:method => :get, :path => 'issues.pdf'},
                    :controller => 'issues', :action => 'index', :format => 'pdf'
                  )
                  assert_routing(
                    {:method => :get, :path => 'issues.atom'},
                    :controller => 'issues', :action => 'index', :format => 'atom'
                  )
                end
                def test_index_pdf
                  get :index, :format => 'pdf'
                  assert_response :success
                  assert_not_nil assigns(:issues)
                  assert_equal 'application/pdf', @response.content_type
                  get :index, :project_id => 1, :format => 'pdf'
                  assert_response :success
                  assert_not_nil assigns(:issues)
                  assert_equal 'application/pdf', @response.content_type
                end
                def test_index_sort
                  get :index, :sort_key => 'tracker'
                  assert_response :success
                  sort_params = @request.session['issuesindex_sort']
                  assert sort_params.is_a?(Hash)
                  assert_equal 'tracker', sort_params[:key]
                  assert_equal 'ASC', sort_params[:order]
                end
                def test_gantt
                  get :gantt, :project_id => 1
                  assert_response :success
                  assert_template 'gantt.rhtml'
                  assert_not_nil assigns(:gantt)
                  events = assigns(:gantt).events
                  assert_not_nil events
                  # Issue with start and due dates
                  i = Issue.find(1)
                  assert_not_nil i.due_date
                  assert events.include?(Issue.find(1))
                  # Issue with without due date but targeted to a version with date
                  i = Issue.find(2)
                  assert_nil i.due_date
                  assert events.include?(i)
                end
                def test_cross_project_gantt
                  get :gantt
                  assert_response :success
                  assert_template 'gantt.rhtml'
                  assert_not_nil assigns(:gantt)
                  events = assigns(:gantt).events
                  assert_not_nil events
                end
                def test_gantt_export_to_pdf
                  get :gantt, :project_id => 1, :format => 'pdf'
                  assert_response :success
                  assert_equal 'application/pdf', @response.content_type
                  assert @response.body.starts_with?('%PDF')
                  assert_not_nil assigns(:gantt)
                end
                def test_cross_project_gantt_export_to_pdf
                  get :gantt, :format => 'pdf'
                  assert_response :success
                  assert_equal 'application/pdf', @response.content_type
                  assert @response.body.starts_with?('%PDF')
                  assert_not_nil assigns(:gantt)
                end
                if Object.const_defined?(:Magick)
                  def test_gantt_image
                    get :gantt, :project_id => 1, :format => 'png'
                    assert_response :success
                    assert_equal 'image/png', @response.content_type
                  end
                else
                  puts "RMagick not installed. Skipping tests !!!"
                end
                def test_calendar
                  get :calendar, :project_id => 1
                  assert_response :success
                  assert_template 'calendar'
                  assert_not_nil assigns(:calendar)
                end
                def test_cross_project_calendar
                  get :calendar
                  assert_response :success
                  assert_template 'calendar'
                  assert_not_nil assigns(:calendar)
                end
                def test_changes
                  get :changes, :project_id => 1
                  assert_response :success
                  assert_not_nil assigns(:journals)
                  assert_equal 'application/atom+xml', @response.content_type
                end
                def test_show_routing
                  assert_routing(
                    {:method => :get, :path => '/issues/64'},
                    :controller => 'issues', :action => 'show', :id => '64'
                  )
                end
                def test_show_routing_formatted
                  assert_routing(
                    {:method => :get, :path => '/issues/2332.pdf'},
                    :controller => 'issues', :action => 'show', :id => '2332', :format => 'pdf'
                  )
                  assert_routing(
                    {:method => :get, :path => '/issues/23123.atom'},
                    :controller => 'issues', :action => 'show', :id => '23123', :format => 'atom'
                  )
                end
                def test_show_by_anonymous
                  get :show, :id => 1
                  assert_response :success
                  assert_template 'show.rhtml'
                  assert_not_nil assigns(:issue)
                  assert_equal Issue.find(1), assigns(:issue)
                  # anonymous role is allowed to add a note
                  assert_tag :tag => 'form',
                             :descendant => { :tag => 'fieldset',
                                              :child => { :tag => 'legend',
                                                          :content => /Notes/ } }
                end
                def test_show_by_manager
                  @request.session[:user_id] = 2
                  get :show, :id => 1
                  assert_response :success
                  assert_tag :tag => 'form',
                             :descendant => { :tag => 'fieldset',
                                              :child => { :tag => 'legend',
                                                          :content => /Change properties/ } },
                             :descendant => { :tag => 'fieldset',
                                              :child => { :tag => 'legend',
                                                          :content => /Log time/ } },
                             :descendant => { :tag => 'fieldset',
                                              :child => { :tag => 'legend',
                                                          :content => /Notes/ } }
                end
                def test_show_should_not_disclose_relations_to_invisible_issues
                  Setting.cross_project_issue_relations = '1'
                  IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => 'relates')
                  # Relation to a private project issue
                  IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(4), :relation_type => 'relates')
                  get :show, :id => 1
                  assert_response :success
                  assert_tag :div, :attributes => { :id => 'relations' },
                                   :descendant => { :tag => 'a', :content => /#2$/ }
                  assert_no_tag :div, :attributes => { :id => 'relations' },
                                      :descendant => { :tag => 'a', :content => /#4$/ }
                end
                def test_new_routing
                  assert_routing(
                    {:method => :get, :path => '/projects/1/issues/new'},
                    :controller => 'issues', :action => 'new', :project_id => '1'
                  )
                  assert_recognizes(
                    {:controller => 'issues', :action => 'new', :project_id => '1'},
                    {:method => :post, :path => '/projects/1/issues'}
                  )
                end
                def test_show_export_to_pdf
                  get :show, :id => 3, :format => 'pdf'
                  assert_response :success
                  assert_equal 'application/pdf', @response.content_type
                  assert @response.body.starts_with?('%PDF')
                  assert_not_nil assigns(:issue)
                end
                def test_get_new
                  @request.session[:user_id] = 2
                  get :new, :project_id => 1, :tracker_id => 1
                  assert_response :success
                  assert_template 'new'
                  assert_tag :tag => 'input', :attributes => { :name => 'issue[custom_field_values][2]',
                                                               :value => 'Default string' }
                end
                def test_get_new_without_tracker_id
                  @request.session[:user_id] = 2
                  get :new, :project_id => 1
                  assert_response :success
                  assert_template 'new'
                  issue = assigns(:issue)
                  assert_not_nil issue
                  assert_equal Project.find(1).trackers.first, issue.tracker
                end
                def test_update_new_form
                  @request.session[:user_id] = 2
                  xhr :post, :new, :project_id => 1,
                                   :issue => {:tracker_id => 2,
                                              :subject => 'This is the test_new issue',
                                              :description => 'This is the description',
                                              :priority_id => 5}
                  assert_response :success
                  assert_template 'new'
                end
                def test_post_new
                  @request.session[:user_id] = 2
                  post :new, :project_id => 1,
                             :issue => {:tracker_id => 3,
                                        :subject => 'This is the test_new issue',
                                        :description => 'This is the description',
                                        :priority_id => 5,
                                        :estimated_hours => '',
                                        :custom_field_values => {'2' => 'Value for field 2'}}
                  assert_redirected_to :action => 'show'
                  issue = Issue.find_by_subject('This is the test_new issue')
                  assert_not_nil issue
                  assert_equal 2, issue.author_id
                  assert_equal 3, issue.tracker_id
                  assert_nil issue.estimated_hours
                  v = issue.custom_values.find(:first, :conditions => {:custom_field_id => 2})
                  assert_not_nil v
                  assert_equal 'Value for field 2', v.value
                end
                def test_post_new_and_continue
                  @request.session[:user_id] = 2
                  post :new, :project_id => 1,
                             :issue => {:tracker_id => 3,
                                        :subject => 'This is first issue',
                                        :priority_id => 5},
                             :continue => ''
                  assert_redirected_to :controller => 'issues', :action => 'new', :tracker_id => 3
                end
                def test_post_new_without_custom_fields_param
                  @request.session[:user_id] = 2
                  post :new, :project_id => 1,
                             :issue => {:tracker_id => 1,
                                        :subject => 'This is the test_new issue',
                                        :description => 'This is the description',
                                        :priority_id => 5}
                  assert_redirected_to :action => 'show'
                end
                def test_post_new_with_required_custom_field_and_without_custom_fields_param
                  field = IssueCustomField.find_by_name('Database')
                  field.update_attribute(:is_required, true)
                  @request.session[:user_id] = 2
                  post :new, :project_id => 1,
                             :issue => {:tracker_id => 1,
                                        :subject => 'This is the test_new issue',
                                        :description => 'This is the description',
                                        :priority_id => 5}
                  assert_response :success
                  assert_template 'new'
                  issue = assigns(:issue)
                  assert_not_nil issue
                  assert_equal 'activerecord_error_invalid', issue.errors.on(:custom_values)
                end
                def test_post_new_with_watchers
                  @request.session[:user_id] = 2
                  ActionMailer::Base.deliveries.clear
                  assert_difference 'Watcher.count', 2 do
                    post :new, :project_id => 1,
                               :issue => {:tracker_id => 1,
                                          :subject => 'This is a new issue with watchers',
                                          :description => 'This is the description',
                                          :priority_id => 5,
                                          :watcher_user_ids => ['2', '3']}
                  end
                  issue = Issue.find_by_subject('This is a new issue with watchers')
                  assert_not_nil issue
                  assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
                  # Watchers added
                  assert_equal [2, 3], issue.watcher_user_ids.sort
                  assert issue.watched_by?(User.find(3))
                  # Watchers notified
                  mail = ActionMailer::Base.deliveries.last
                  assert_kind_of TMail::Mail, mail
                  assert [mail.bcc, mail.cc].flatten.include?(User.find(3).mail)
                end
                def test_post_should_preserve_fields_values_on_validation_failure
                  @request.session[:user_id] = 2
                  post :new, :project_id => 1,
                             :issue => {:tracker_id => 1,
                                        # empty subject
                                        :subject => '',
                                        :description => 'This is a description',
                                        :priority_id => 6,
                                        :custom_field_values => {'1' => 'Oracle', '2' => 'Value for field 2'}}
                  assert_response :success
                  assert_template 'new'
                  assert_tag :textarea, :attributes => { :name => 'issue[description]' },
                                        :content => 'This is a description'
                  assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
                                      :child => { :tag => 'option', :attributes => { :selected => 'selected',
                                                                                     :value => '6' },
                                                                    :content => 'High' }
                  # Custom fields
                  assert_tag :select, :attributes => { :name => 'issue[custom_field_values][1]' },
                                      :child => { :tag => 'option', :attributes => { :selected => 'selected',
                                                                                     :value => 'Oracle' },
                                                                    :content => 'Oracle' }
                  assert_tag :input, :attributes => { :name => 'issue[custom_field_values][2]',
                                                      :value => 'Value for field 2'}
                end
                def test_copy_routing
                  assert_routing(
                    {:method => :get, :path => '/projects/world_domination/issues/567/copy'},
                    :controller => 'issues', :action => 'new', :project_id => 'world_domination', :copy_from => '567'
                  )
                end
                def test_copy_issue
                  @request.session[:user_id] = 2
                  get :new, :project_id => 1, :copy_from => 1
                  assert_template 'new'
                  assert_not_nil assigns(:issue)
                  orig = Issue.find(1)
                  assert_equal orig.subject, assigns(:issue).subject
                end
                def test_edit_routing
                  assert_routing(
                    {:method => :get, :path => '/issues/1/edit'},
                    :controller => 'issues', :action => 'edit', :id => '1'
                  )
                  assert_recognizes( #TODO: use a PUT on the issue URI isntead, need to adjust form
                    {:controller => 'issues', :action => 'edit', :id => '1'},
                    {:method => :post, :path => '/issues/1/edit'}
                  )
                end
                def test_get_edit
                  @request.session[:user_id] = 2
                  get :edit, :id => 1
                  assert_response :success
                  assert_template 'edit'
                  assert_not_nil assigns(:issue)
                  assert_equal Issue.find(1), assigns(:issue)
                end
                def test_get_edit_with_params
                  @request.session[:user_id] = 2
                  get :edit, :id => 1, :issue => { :status_id => 5, :priority_id => 7 }
                  assert_response :success
                  assert_template 'edit'
                  issue = assigns(:issue)
                  assert_not_nil issue
                  assert_equal 5, issue.status_id
                  assert_tag :select, :attributes => { :name => 'issue[status_id]' },
                                      :child => { :tag => 'option',
                                                  :content => 'Closed',
                                                  :attributes => { :selected => 'selected' } }
                  assert_equal 7, issue.priority_id
                  assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
                                      :child => { :tag => 'option',
                                                  :content => 'Urgent',
                                                  :attributes => { :selected => 'selected' } }
                end
                def test_reply_routing
                  assert_routing(
                    {:method => :post, :path => '/issues/1/quoted'},
                    :controller => 'issues', :action => 'reply', :id => '1'
                  )
                end
                def test_reply_to_issue
                  @request.session[:user_id] = 2
                  get :reply, :id => 1
                  assert_response :success
                  assert_select_rjs :show, "update"
                end
                def test_reply_to_note
                  @request.session[:user_id] = 2
                  get :reply, :id => 1, :journal_id => 2
                  assert_response :success
                  assert_select_rjs :show, "update"
                end
                def test_post_edit_without_custom_fields_param
                  @request.session[:user_id] = 2
                  ActionMailer::Base.deliveries.clear
                  issue = Issue.find(1)
                  assert_equal '125', issue.custom_value_for(2).value
                  old_subject = issue.subject
                  new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'
                  assert_difference('Journal.count') do
                    assert_difference('JournalDetail.count', 2) do
                      post :edit, :id => 1, :issue => {:subject => new_subject,
                                                       :priority_id => '6',
                                                       :category_id => '1' # no change
                                                      }
                    end
                  end
                  assert_redirected_to :action => 'show', :id => '1'
                  issue.reload
                  assert_equal new_subject, issue.subject
                  # Make sure custom fields were not cleared
                  assert_equal '125', issue.custom_value_for(2).value
                  mail = ActionMailer::Base.deliveries.last
                  assert_kind_of TMail::Mail, mail
                  assert mail.subject.starts_with?("[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}]")
                  assert mail.body.include?("Subject changed from #{old_subject} to #{new_subject}")
                end
                def test_post_edit_with_custom_field_change
                  @request.session[:user_id] = 2
                  issue = Issue.find(1)
                  assert_equal '125', issue.custom_value_for(2).value
                  assert_difference('Journal.count') do
                    assert_difference('JournalDetail.count', 3) do
                      post :edit, :id => 1, :issue => {:subject => 'Custom field change',
                                                       :priority_id => '6',
                                                       :category_id => '1', # no change
                                                       :custom_field_values => { '2' => 'New custom value' }
                                                      }
                    end
                  end
                  assert_redirected_to :action => 'show', :id => '1'
                  issue.reload
                  assert_equal 'New custom value', issue.custom_value_for(2).value
                  mail = ActionMailer::Base.deliveries.last
                  assert_kind_of TMail::Mail, mail
                  assert mail.body.include?("Searchable field changed from 125 to New custom value")
                end
                def test_post_edit_with_status_and_assignee_change
                  issue = Issue.find(1)
                  assert_equal 1, issue.status_id
                  @request.session[:user_id] = 2
                  assert_difference('TimeEntry.count', 0) do
                    post :edit,
                         :id => 1,
                         :issue => { :status_id => 2, :assigned_to_id => 3 },
                         :notes => 'Assigned to dlopper',
-                        :time_entry => { :hours => '', :comments => '', :activity_id => Enumeration.get_values('ACTI').first }
+                        :time_entry => { :hours => '', :comments => '', :activity_id => Enumeration.activities.first }
                  end
                  assert_redirected_to :action => 'show', :id => '1'
                  issue.reload
                  assert_equal 2, issue.status_id
                  j = issue.journals.find(:first, :order => 'id DESC')
                  assert_equal 'Assigned to dlopper', j.notes
                  assert_equal 2, j.details.size
                  mail = ActionMailer::Base.deliveries.last
                  assert mail.body.include?("Status changed from New to Assigned")
                end
                def test_post_edit_with_note_only
                  notes = 'Note added by IssuesControllerTest#test_update_with_note_only'
                  # anonymous user
                  post :edit,
                       :id => 1,
                       :notes => notes
                  assert_redirected_to :action => 'show', :id => '1'
                  j = Issue.find(1).journals.find(:first, :order => 'id DESC')
                  assert_equal notes, j.notes
                  assert_equal 0, j.details.size
                  assert_equal User.anonymous, j.user
                  mail = ActionMailer::Base.deliveries.last
                  assert mail.body.include?(notes)
                end
                def test_post_edit_with_note_and_spent_time
                  @request.session[:user_id] = 2
                  spent_hours_before = Issue.find(1).spent_hours
                  assert_difference('TimeEntry.count') do
                    post :edit,
                         :id => 1,
                         :notes => '2.5 hours added',
-                        :time_entry => { :hours => '2.5', :comments => '', :activity_id => Enumeration.get_values('ACTI').first }
+                        :time_entry => { :hours => '2.5', :comments => '', :activity_id => Enumeration.activities.first }
                  end
                  assert_redirected_to :action => 'show', :id => '1'
                  issue = Issue.find(1)
                  j = issue.journals.find(:first, :order => 'id DESC')
                  assert_equal '2.5 hours added', j.notes
                  assert_equal 0, j.details.size
                  t = issue.time_entries.find(:first, :order => 'id DESC')
                  assert_not_nil t
                  assert_equal 2.5, t.hours
                  assert_equal spent_hours_before + 2.5, issue.spent_hours
                end
                def test_post_edit_with_attachment_only
                  set_tmp_attachments_directory
                  # Delete all fixtured journals, a race condition can occur causing the wrong
                  # journal to get fetched in the next find.
                  Journal.delete_all
                  # anonymous user
                  post :edit,
                       :id => 1,
                       :notes => '',
                       :attachments => {'1' => {'file' => test_uploaded_file('testfile.txt', 'text/plain')}}
                  assert_redirected_to :action => 'show', :id => '1'
                  j = Issue.find(1).journals.find(:first, :order => 'id DESC')
                  assert j.notes.blank?
                  assert_equal 1, j.details.size
                  assert_equal 'testfile.txt', j.details.first.value
                  assert_equal User.anonymous, j.user
                  mail = ActionMailer::Base.deliveries.last
                  assert mail.body.include?('testfile.txt')
                end
                def test_post_edit_with_no_change
                  issue = Issue.find(1)
                  issue.journals.clear
                  ActionMailer::Base.deliveries.clear
                  post :edit,
                       :id => 1,
                       :notes => ''
                  assert_redirected_to :action => 'show', :id => '1'
                  issue.reload
                  assert issue.journals.empty?
                  # No email should be sent
                  assert ActionMailer::Base.deliveries.empty?
                end
                def test_post_edit_with_invalid_spent_time
                  @request.session[:user_id] = 2
                  notes = 'Note added by IssuesControllerTest#test_post_edit_with_invalid_spent_time'
                  assert_no_difference('Journal.count') do
                    post :edit,
                         :id => 1,
                         :notes => notes,
                         :time_entry => {"comments"=>"", "activity_id"=>"", "hours"=>"2z"}
                  end
                  assert_response :success
                  assert_template 'edit'
                  assert_tag :textarea, :attributes => { :name => 'notes' },
                                        :content => notes
                  assert_tag :input, :attributes => { :name => 'time_entry[hours]', :value => "2z" }
                end
                def test_bulk_edit
                  @request.session[:user_id] = 2
                  # update issues priority
                  post :bulk_edit, :ids => [1, 2], :priority_id => 7,
                                                   :assigned_to_id => '',
                                                   :custom_field_values => {'2' => ''},
                                                   :notes => 'Bulk editing'
                  assert_response 302
                  # check that the issues were updated
                  assert_equal [7, 7], Issue.find_all_by_id([1, 2]).collect {|i| i.priority.id}
                  issue = Issue.find(1)
                  journal = issue.journals.find(:first, :order => 'created_on DESC')
                  assert_equal '125', issue.custom_value_for(2).value
                  assert_equal 'Bulk editing', journal.notes
                  assert_equal 1, journal.details.size
                end
                def test_bulk_edit_custom_field
                  @request.session[:user_id] = 2
                  # update issues priority
                  post :bulk_edit, :ids => [1, 2], :priority_id => '',
                                                   :assigned_to_id => '',
                                                   :custom_field_values => {'2' => '777'},
                                                   :notes => 'Bulk editing custom field'
                  assert_response 302
                  issue = Issue.find(1)
                  journal = issue.journals.find(:first, :order => 'created_on DESC')
                  assert_equal '777', issue.custom_value_for(2).value
                  assert_equal 1, journal.details.size
                  assert_equal '125', journal.details.first.old_value
                  assert_equal '777', journal.details.first.value
                end
                def test_bulk_unassign
                  assert_not_nil Issue.find(2).assigned_to
                  @request.session[:user_id] = 2
                  # unassign issues
                  post :bulk_edit, :ids => [1, 2], :notes => 'Bulk unassigning', :assigned_to_id => 'none'
                  assert_response 302
                  # check that the issues were updated
                  assert_nil Issue.find(2).assigned_to
                end
                def test_move_routing
                  assert_routing(
                    {:method => :get, :path => '/issues/1/move'},
                    :controller => 'issues', :action => 'move', :id => '1'
                  )
                  assert_recognizes(
                    {:controller => 'issues', :action => 'move', :id => '1'},
                    {:method => :post, :path => '/issues/1/move'}
                  )
                end
                def test_move_one_issue_to_another_project
                  @request.session[:user_id] = 1
                  post :move, :id => 1, :new_project_id => 2
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  assert_equal 2, Issue.find(1).project_id
                end
                def test_bulk_move_to_another_project
                  @request.session[:user_id] = 1
                  post :move, :ids => [1, 2], :new_project_id => 2
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  # Issues moved to project 2
                  assert_equal 2, Issue.find(1).project_id
                  assert_equal 2, Issue.find(2).project_id
                  # No tracker change
                  assert_equal 1, Issue.find(1).tracker_id
                  assert_equal 2, Issue.find(2).tracker_id
                end
                def test_bulk_move_to_another_tracker
                  @request.session[:user_id] = 1
                  post :move, :ids => [1, 2], :new_tracker_id => 2
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  assert_equal 2, Issue.find(1).tracker_id
                  assert_equal 2, Issue.find(2).tracker_id
                end
                def test_bulk_copy_to_another_project
                  @request.session[:user_id] = 1
                  assert_difference 'Issue.count', 2 do
                    assert_no_difference 'Project.find(1).issues.count' do
                      post :move, :ids => [1, 2], :new_project_id => 2, :copy_options => {:copy => '1'}
                    end
                  end
                  assert_redirected_to 'projects/ecookbook/issues'
                end
                def test_context_menu_one_issue
                  @request.session[:user_id] = 2
                  get :context_menu, :ids => [1]
                  assert_response :success
                  assert_template 'context_menu'
                  assert_tag :tag => 'a', :content => 'Edit',
                                          :attributes => { :href => '/issues/1/edit',
                                                           :class => 'icon-edit' }
                  assert_tag :tag => 'a', :content => 'Closed',
                                          :attributes => { :href => '/issues/1/edit?issue%5Bstatus_id%5D=5',
                                                           :class => '' }
                  assert_tag :tag => 'a', :content => 'Immediate',
                                          :attributes => { :href => '/issues/bulk_edit?ids%5B%5D=1&amp;priority_id=8',
                                                           :class => '' }
                  assert_tag :tag => 'a', :content => 'Dave Lopper',
                                          :attributes => { :href => '/issues/bulk_edit?assigned_to_id=3&amp;ids%5B%5D=1',
                                                           :class => '' }
                  assert_tag :tag => 'a', :content => 'Copy',
                                          :attributes => { :href => '/projects/ecookbook/issues/1/copy',
                                                           :class => 'icon-copy' }
                  assert_tag :tag => 'a', :content => 'Move',
                                          :attributes => { :href => '/issues/move?ids%5B%5D=1',
                                                           :class => 'icon-move' }
                  assert_tag :tag => 'a', :content => 'Delete',
                                          :attributes => { :href => '/issues/destroy?ids%5B%5D=1',
                                                           :class => 'icon-del' }
                end
                def test_context_menu_one_issue_by_anonymous
                  get :context_menu, :ids => [1]
                  assert_response :success
                  assert_template 'context_menu'
                  assert_tag :tag => 'a', :content => 'Delete',
                                          :attributes => { :href => '#',
                                                           :class => 'icon-del disabled' }
                end
                def test_context_menu_multiple_issues_of_same_project
                  @request.session[:user_id] = 2
                  get :context_menu, :ids => [1, 2]
                  assert_response :success
                  assert_template 'context_menu'
                  assert_tag :tag => 'a', :content => 'Edit',
                                          :attributes => { :href => '/issues/bulk_edit?ids%5B%5D=1&amp;ids%5B%5D=2',
                                                           :class => 'icon-edit' }
                  assert_tag :tag => 'a', :content => 'Immediate',
                                          :attributes => { :href => '/issues/bulk_edit?ids%5B%5D=1&amp;ids%5B%5D=2&amp;priority_id=8',
                                                           :class => '' }
                  assert_tag :tag => 'a', :content => 'Dave Lopper',
                                          :attributes => { :href => '/issues/bulk_edit?assigned_to_id=3&amp;ids%5B%5D=1&amp;ids%5B%5D=2',
                                                           :class => '' }
                  assert_tag :tag => 'a', :content => 'Move',
                                          :attributes => { :href => '/issues/move?ids%5B%5D=1&amp;ids%5B%5D=2',
                                                           :class => 'icon-move' }
                  assert_tag :tag => 'a', :content => 'Delete',
                                          :attributes => { :href => '/issues/destroy?ids%5B%5D=1&amp;ids%5B%5D=2',
                                                           :class => 'icon-del' }
                end
                def test_context_menu_multiple_issues_of_different_project
                  @request.session[:user_id] = 2
                  get :context_menu, :ids => [1, 2, 4]
                  assert_response :success
                  assert_template 'context_menu'
                  assert_tag :tag => 'a', :content => 'Delete',
                                          :attributes => { :href => '#',
                                                           :class => 'icon-del disabled' }
                end
                def test_destroy_routing
                  assert_recognizes( #TODO: use DELETE on issue URI (need to change forms)
                    {:controller => 'issues', :action => 'destroy', :id => '1'},
                    {:method => :post, :path => '/issues/1/destroy'}
                  )
                end
                def test_destroy_issue_with_no_time_entries
                  assert_nil TimeEntry.find_by_issue_id(2)
                  @request.session[:user_id] = 2
                  post :destroy, :id => 2
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  assert_nil Issue.find_by_id(2)
                end
                def test_destroy_issues_with_time_entries
                  @request.session[:user_id] = 2
                  post :destroy, :ids => [1, 3]
                  assert_response :success
                  assert_template 'destroy'
                  assert_not_nil assigns(:hours)
                  assert Issue.find_by_id(1) && Issue.find_by_id(3)
                end
                def test_destroy_issues_and_destroy_time_entries
                  @request.session[:user_id] = 2
                  post :destroy, :ids => [1, 3], :todo => 'destroy'
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                  assert_nil TimeEntry.find_by_id([1, 2])
                end
                def test_destroy_issues_and_assign_time_entries_to_project
                  @request.session[:user_id] = 2
                  post :destroy, :ids => [1, 3], :todo => 'nullify'
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                  assert_nil TimeEntry.find(1).issue_id
                  assert_nil TimeEntry.find(2).issue_id
                end
                def test_destroy_issues_and_reassign_time_entries_to_another_issue
                  @request.session[:user_id] = 2
                  post :destroy, :ids => [1, 3], :todo => 'reassign', :reassign_to_id => 2
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                  assert_equal 2, TimeEntry.find(1).issue_id
                  assert_equal 2, TimeEntry.find(2).issue_id
                end
              end

test/unit/enumeration_test.rb +8 -8

              # redMine - project management software
              # Copyright (C) 2006-2008  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.dirname(__FILE__) + '/../test_helper'
              class EnumerationTest < Test::Unit::TestCase
                fixtures :enumerations, :issues
                def setup
                end
                def test_objects_count
                  # low priority
                  assert_equal 5, Enumeration.find(4).objects_count
                  # urgent
                  assert_equal 0, Enumeration.find(7).objects_count
                end
                def test_in_use
                  # low priority
                  assert Enumeration.find(4).in_use?
                  # urgent
                  assert !Enumeration.find(7).in_use?
                end
                def test_default
-                 e = Enumeration.default('IPRI')
+                 e = Enumeration.priorities.default
                  assert e.is_a?(Enumeration)
                  assert e.is_default?
                  assert_equal 'Normal', e.name
                end
                def test_create
                  e = Enumeration.new(:opt => 'IPRI', :name => 'Very urgent', :is_default => false)
                  assert e.save
-                 assert_equal 'Normal', Enumeration.default('IPRI').name
+                 assert_equal 'Normal', Enumeration.priorities.default.name
                end
                def test_create_as_default
                  e = Enumeration.new(:opt => 'IPRI', :name => 'Very urgent', :is_default => true)
                  assert e.save
-                 assert_equal e, Enumeration.default('IPRI')
+                 assert_equal e, Enumeration.priorities.default
                end
                def test_update_default
-                 e = Enumeration.default('IPRI')
+                 e = Enumeration.priorities.default
                  e.update_attributes(:name => 'Changed', :is_default => true)
-                 assert_equal e, Enumeration.default('IPRI')
+                 assert_equal e, Enumeration.priorities.default
                end
                def test_update_default_to_non_default
-                 e = Enumeration.default('IPRI')
+                 e = Enumeration.priorities.default
                  e.update_attributes(:name => 'Changed', :is_default => false)
-                 assert_nil Enumeration.default('IPRI')
+                 assert_nil Enumeration.priorities.default
                end
                def test_change_default
                  e = Enumeration.find_by_name('Urgent')
                  e.update_attributes(:name => 'Urgent', :is_default => true)
-                 assert_equal e, Enumeration.default('IPRI')
+                 assert_equal e, Enumeration.priorities.default
                end
                def test_destroy_with_reassign
                  Enumeration.find(4).destroy(Enumeration.find(6))
                  assert_nil Issue.find(:first, :conditions => {:priority_id => 4})
                  assert_equal 5, Enumeration.find(6).objects_count
                end
              end

test/unit/issue_test.rb +5 -5

              # redMine - project management software
              # Copyright (C) 2006-2007  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.dirname(__FILE__) + '/../test_helper'
              class IssueTest < Test::Unit::TestCase
                fixtures :projects, :users, :members,
                         :trackers, :projects_trackers,
                         :issue_statuses, :issue_categories,
                         :enumerations,
                         :issues,
                         :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
                         :time_entries
                def test_create
-                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'test_create', :description => 'IssueTest#test_create', :estimated_hours => '1:30')
+                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.priorities.first, :subject => 'test_create', :description => 'IssueTest#test_create', :estimated_hours => '1:30')
                  assert issue.save
                  issue.reload
                  assert_equal 1.5, issue.estimated_hours
                end
                def test_create_minimal
-                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'test_create')
+                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.priorities.first, :subject => 'test_create')
                  assert issue.save
                  assert issue.description.nil?
                end
                def test_create_with_required_custom_field
                  field = IssueCustomField.find_by_name('Database')
                  field.update_attribute(:is_required, true)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field')
                  assert issue.available_custom_fields.include?(field)
                  # No value for the custom field
                  assert !issue.save
                  assert_equal 'activerecord_error_invalid', issue.errors.on(:custom_values)
                  # Blank value
                  issue.custom_field_values = { field.id => '' }
                  assert !issue.save
                  assert_equal 'activerecord_error_invalid', issue.errors.on(:custom_values)
                  # Invalid value
                  issue.custom_field_values = { field.id => 'SQLServer' }
                  assert !issue.save
                  assert_equal 'activerecord_error_invalid', issue.errors.on(:custom_values)
                  # Valid value
                  issue.custom_field_values = { field.id => 'PostgreSQL' }
                  assert issue.save
                  issue.reload
                  assert_equal 'PostgreSQL', issue.custom_value_for(field).value
                end
                def test_update_issue_with_required_custom_field
                  field = IssueCustomField.find_by_name('Database')
                  field.update_attribute(:is_required, true)
                  issue = Issue.find(1)
                  assert_nil issue.custom_value_for(field)
                  assert issue.available_custom_fields.include?(field)
                  # No change to custom values, issue can be saved
                  assert issue.save
                  # Blank value
                  issue.custom_field_values = { field.id => '' }
                  assert !issue.save
                  # Valid value
                  issue.custom_field_values = { field.id => 'PostgreSQL' }
                  assert issue.save
                  issue.reload
                  assert_equal 'PostgreSQL', issue.custom_value_for(field).value
                end
                def test_should_not_update_attributes_if_custom_fields_validation_fails
                  issue = Issue.find(1)
                  field = IssueCustomField.find_by_name('Database')
                  assert issue.available_custom_fields.include?(field)
                  issue.custom_field_values = { field.id => 'Invalid' }
                  issue.subject = 'Should be not be saved'
                  assert !issue.save
                  issue.reload
                  assert_equal "Can't print recipes", issue.subject
                end
                def test_should_not_recreate_custom_values_objects_on_update
                  field = IssueCustomField.find_by_name('Database')
                  issue = Issue.find(1)
                  issue.custom_field_values = { field.id => 'PostgreSQL' }
                  assert issue.save
                  custom_value = issue.custom_value_for(field)
                  issue.reload
                  issue.custom_field_values = { field.id => 'MySQL' }
                  assert issue.save
                  issue.reload
                  assert_equal custom_value.id, issue.custom_value_for(field).id
                end
                def test_category_based_assignment
-                 issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'Assignment test', :description => 'Assignment test', :category_id => 1)
+                 issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.priorities.first, :subject => 'Assignment test', :description => 'Assignment test', :category_id => 1)
                  assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to
                end
                def test_copy
                  issue = Issue.new.copy_from(1)
                  assert issue.save
                  issue.reload
                  orig = Issue.find(1)
                  assert_equal orig.subject, issue.subject
                  assert_equal orig.tracker, issue.tracker
                  assert_equal orig.custom_values.first.value, issue.custom_values.first.value
                end
                def test_should_close_duplicates
                  # Create 3 issues
-                 issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'Duplicates test', :description => 'Duplicates test')
+                 issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => Enumeration.priorities.first, :subject => 'Duplicates test', :description => 'Duplicates test')
                  assert issue1.save
                  issue2 = issue1.clone
                  assert issue2.save
                  issue3 = issue1.clone
                  assert issue3.save
                  # 2 is a dupe of 1
                  IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # And 3 is a dupe of 2
                  IssueRelation.create(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # And 3 is a dupe of 1 (circular duplicates)
                  IssueRelation.create(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                  assert issue1.reload.duplicates.include?(issue2)
                  # Closing issue 1
                  issue1.init_journal(User.find(:first), "Closing issue1")
                  issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}
                  assert issue1.save
                  # 2 and 3 should be also closed
                  assert issue2.reload.closed?
                  assert issue3.reload.closed?
                end
                def test_should_not_close_duplicated_issue
                  # Create 3 issues
-                 issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'Duplicates test', :description => 'Duplicates test')
+                 issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => Enumeration.priorities.first, :subject => 'Duplicates test', :description => 'Duplicates test')
                  assert issue1.save
                  issue2 = issue1.clone
                  assert issue2.save
                  # 2 is a dupe of 1
                  IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # 2 is a dup of 1 but 1 is not a duplicate of 2
                  assert !issue2.reload.duplicates.include?(issue1)
                  # Closing issue 2
                  issue2.init_journal(User.find(:first), "Closing issue2")
                  issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true}
                  assert issue2.save
                  # 1 should not be also closed
                  assert !issue1.reload.closed?
                end
                def test_move_to_another_project_with_same_category
                  issue = Issue.find(1)
                  assert issue.move_to(Project.find(2))
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Category changes
                  assert_equal 4, issue.category_id
                  # Make sure time entries were move to the target project
                  assert_equal 2, issue.time_entries.first.project_id
                end
                def test_move_to_another_project_without_same_category
                  issue = Issue.find(2)
                  assert issue.move_to(Project.find(2))
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Category cleared
                  assert_nil issue.category_id
                end
                def test_copy_to_the_same_project
                  issue = Issue.find(1)
                  copy = nil
                  assert_difference 'Issue.count' do
                    copy = issue.move_to(issue.project, nil, :copy => true)
                  end
                  assert_kind_of Issue, copy
                  assert_equal issue.project, copy.project
                  assert_equal "125", copy.custom_value_for(2).value
                end
                def test_copy_to_another_project_and_tracker
                  issue = Issue.find(1)
                  copy = nil
                  assert_difference 'Issue.count' do
                    copy = issue.move_to(Project.find(3), Tracker.find(2), :copy => true)
                  end
                  assert_kind_of Issue, copy
                  assert_equal Project.find(3), copy.project
                  assert_equal Tracker.find(2), copy.tracker
                  # Custom field #2 is not associated with target tracker
                  assert_nil copy.custom_value_for(2)
                end
                def test_issue_destroy
                  Issue.find(1).destroy
                  assert_nil Issue.find_by_id(1)
                  assert_nil TimeEntry.find_by_issue_id(1)
                end
                def test_overdue
                  assert Issue.new(:due_date => 1.day.ago.to_date).overdue?
                  assert !Issue.new(:due_date => Date.today).overdue?
                  assert !Issue.new(:due_date => 1.day.from_now.to_date).overdue?
                  assert !Issue.new(:due_date => nil).overdue?
                  assert !Issue.new(:due_date => 1.day.ago.to_date, :status => IssueStatus.find(:first, :conditions => {:is_closed => true})).overdue?
                end
              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