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},
+                "IPRI" => {:label => :enumeration_issue_priorities, :model => Issue, :foreign_key => :priority_id, :scope => :priorities},
-                "DCAT" => {:label => :enumeration_doc_categories, :model => Document, :foreign_key => :category_id},
+                "DCAT" => {:label => :enumeration_doc_categories, :model => Document, :foreign_key => :category_id, :scope => :document_categories},
-                "ACTI" => {:label => :enumeration_activities, :model => TimeEntry, :foreign_key => :activity_id}
+                "ACTI" => {:label => :enumeration_activities, :model => TimeEntry, :foreign_key => :activity_id, :scope => :activities}
               }.freeze
-              def self.get_values(option)
+              # Creates a named scope for each type of value. The scope has a +default+ method
-                find(:all, :conditions => {:opt => option}, :order => 'position')
+              # 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)
+              named_scope :values, lambda {|opt| { :conditions => { :opt => opt }, :order => 'position' } } do
-                find(:first, :conditions => {:opt => option, :is_default => true}, :order => 'position')
+                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