jro_apps/redmine Commit - r4479:44ffc5a3365f

Remove the limitation on characters that can be used in custom_field, issue_status, role, tracker, user names (#5152)....

Jean-Philippe Lang -

r4479:44ffc5a3365f

parent child

Context file:

r4479:44ffc5a3365f

Collapse all files

app/models/custom_field.rb 0 -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 CustomField < ActiveRecord::Base
               has_many :custom_values, :dependent => :delete_all
               acts_as_list :scope => 'type = \'#{self.class}\''
               serialize :possible_values
               validates_presence_of :name, :field_format
               validates_uniqueness_of :name, :scope => :type
               validates_length_of :name, :maximum => 30
-              validates_format_of :name, :with => /^[\w\s\.\'\-]*$/i
               validates_inclusion_of :field_format, :in => Redmine::CustomFieldFormat.available_formats
               def initialize(attributes = nil)
                 super
                 self.possible_values ||= []
               end
               def before_validation
                 # make sure these fields are not searchable
                 self.searchable = false if %w(int float date bool).include?(field_format)
                 true
               end
               def validate
                 if self.field_format == "list"
                   errors.add(:possible_values, :blank) if self.possible_values.nil? || self.possible_values.empty?
                   errors.add(:possible_values, :invalid) unless self.possible_values.is_a? Array
                 end
                 # validate default value
                 v = CustomValue.new(:custom_field => self.clone, :value => default_value, :customized => nil)
                 v.custom_field.is_required = false
                 errors.add(:default_value, :invalid) unless v.valid?
               end
               # Makes possible_values accept a multiline string
               def possible_values=(arg)
                 if arg.is_a?(Array)
                   write_attribute(:possible_values, arg.compact.collect(&:strip).select {|v| !v.blank?})
                 else
                   self.possible_values = arg.to_s.split(/[\n\r]+/)
                 end
               end
               def cast_value(value)
                 casted = nil
                 unless value.blank?
                   case field_format
                   when 'string', 'text', 'list'
                     casted = value
                   when 'date'
                     casted = begin; value.to_date; rescue; nil end
                   when 'bool'
                     casted = (value == '1' ? true : false)
                   when 'int'
                     casted = value.to_i
                   when 'float'
                     casted = value.to_f
                   end
                 end
                 casted
               end
               # Returns a ORDER BY clause that can used to sort customized
               # objects by their value of the custom field.
               # Returns false, if the custom field can not be used for sorting.
               def order_statement
                 case field_format
                   when 'string', 'text', 'list', 'date', 'bool'
                     # COALESCE is here to make sure that blank and NULL values are sorted equally
                     "COALESCE((SELECT cv_sort.value FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} LIMIT 1), '')"
                   when 'int', 'float'
                     # Make the database cast values into numeric
                     # Postgresql will raise an error if a value can not be casted!
                     # CustomValue validations should ensure that it doesn't occur
                     "(SELECT CAST(cv_sort.value AS decimal(60,3)) FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} AND cv_sort.value <> '' AND cv_sort.value IS NOT NULL LIMIT 1)"
                   else
                     nil
                 end
               end
               def <=>(field)
                 position <=> field.position
               end
               def self.customized_class
                 self.name =~ /^(.+)CustomField$/
                 begin; $1.constantize; rescue nil; end
               end
               # to move in project_custom_field
               def self.for_all
                 find(:all, :conditions => ["is_for_all=?", true], :order => 'position')
               end
               def type_name
                 nil
               end
             end

app/models/issue_status.rb 0 -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 IssueStatus < ActiveRecord::Base
               before_destroy :check_integrity
               has_many :workflows, :foreign_key => "old_status_id"
               acts_as_list
               before_destroy :delete_workflows
               validates_presence_of :name
               validates_uniqueness_of :name
               validates_length_of :name, :maximum => 30
-              validates_format_of :name, :with => /^[\w\s\'\-]*$/i
               validates_inclusion_of :default_done_ratio, :in => 0..100, :allow_nil => true
               def after_save
                 IssueStatus.update_all("is_default=#{connection.quoted_false}", ['id <> ?', id]) if self.is_default?
               end
               # Returns the default status for new issues
               def self.default
                 find(:first, :conditions =>["is_default=?", true])
               end
               # Update all the +Issues+ setting their done_ratio to the value of their +IssueStatus+
               def self.update_issue_done_ratios
                 if Issue.use_status_for_done_ratio?
                   IssueStatus.find(:all, :conditions => ["default_done_ratio >= 0"]).each do |status|
                     Issue.update_all(["done_ratio = ?", status.default_done_ratio],
                                      ["status_id = ?", status.id])
                   end
                 end
                 return Issue.use_status_for_done_ratio?
               end
               # Returns an array of all statuses the given role can switch to
               # Uses association cache when called more than one time
               def new_statuses_allowed_to(roles, tracker)
                 if roles && tracker
                   role_ids = roles.collect(&:id)
                   new_statuses = workflows.select {|w| role_ids.include?(w.role_id) && w.tracker_id == tracker.id}.collect{|w| w.new_status}.compact.sort
                 else
                   []
                 end
               end
               # Same thing as above but uses a database query
               # More efficient than the previous method if called just once
               def find_new_statuses_allowed_to(roles, tracker)
                 if roles && tracker
                   workflows.find(:all,
                                  :include => :new_status,
                                  :conditions => { :role_id => roles.collect(&:id),
                                                   :tracker_id => tracker.id}).collect{ |w| w.new_status }.compact.sort
                 else
                   []
                 end
               end
               def new_status_allowed_to?(status, roles, tracker)
                 if status && roles && tracker
                   !workflows.find(:first, :conditions => {:new_status_id => status.id, :role_id => roles.collect(&:id), :tracker_id => tracker.id}).nil?
                 else
                   false
                 end
               end
               def <=>(status)
                 position <=> status.position
               end
               def to_s; name end
             private
               def check_integrity
                 raise "Can't delete status" if Issue.find(:first, :conditions => ["status_id=?", self.id])
               end
               # Deletes associated workflows
               def delete_workflows
                 Workflow.delete_all(["old_status_id = :id OR new_status_id = :id", {:id => id}])
               end
             end

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

app/models/tracker.rb 0 -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 Tracker < ActiveRecord::Base
               before_destroy :check_integrity
               has_many :issues
               has_many :workflows, :dependent => :delete_all do
                 def copy(source_tracker)
                   Workflow.copy(source_tracker, nil, proxy_owner, nil)
                 end
               end
               has_and_belongs_to_many :projects
               has_and_belongs_to_many :custom_fields, :class_name => 'IssueCustomField', :join_table => "#{table_name_prefix}custom_fields_trackers#{table_name_suffix}", :association_foreign_key => 'custom_field_id'
               acts_as_list
               validates_presence_of :name
               validates_uniqueness_of :name
               validates_length_of :name, :maximum => 30
-              validates_format_of :name, :with => /^[\w\s\'\-]*$/i
               def to_s; name end
               def <=>(tracker)
                 name <=> tracker.name
               end
               def self.all
                 find(:all, :order => 'position')
               end
               # Returns an array of IssueStatus that are used
               # in the tracker's workflows
               def issue_statuses
                 if @issue_statuses
                   return @issue_statuses
                 elsif new_record?
                   return []
                 end
                 ids = Workflow.
                         connection.select_rows("SELECT DISTINCT old_status_id, new_status_id FROM #{Workflow.table_name} WHERE tracker_id = #{id}").
                         flatten.
                         uniq
                 @issue_statuses = IssueStatus.find_all_by_id(ids).sort
               end
             private
               def check_integrity
                 raise "Can't delete tracker" if Issue.find(:first, :conditions => ["tracker_id=?", self.id])
               end
             end

app/models/user.rb 0 -1

             # Redmine - project management software
             # Copyright (C) 2006-2009  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require "digest/sha1"
             class User < Principal
               include Redmine::SafeAttributes
               # Account statuses
               STATUS_ANONYMOUS  = 0
               STATUS_ACTIVE     = 1
               STATUS_REGISTERED = 2
               STATUS_LOCKED     = 3
               USER_FORMATS = {
                 :firstname_lastname => '#{firstname} #{lastname}',
                 :firstname => '#{firstname}',
                 :lastname_firstname => '#{lastname} #{firstname}',
                 :lastname_coma_firstname => '#{lastname}, #{firstname}',
                 :username => '#{login}'
               }
               MAIL_NOTIFICATION_OPTIONS = [
                 ['all', :label_user_mail_option_all],
                 ['selected', :label_user_mail_option_selected],
                 ['only_my_events', :label_user_mail_option_only_my_events],
                 ['only_assigned', :label_user_mail_option_only_assigned],
                 ['only_owner', :label_user_mail_option_only_owner],
                 ['none', :label_user_mail_option_none]
               ]
               has_and_belongs_to_many :groups, :after_add => Proc.new {|user, group| group.user_added(user)},
                                                :after_remove => Proc.new {|user, group| group.user_removed(user)}
               has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
               has_many :changesets, :dependent => :nullify
               has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
               has_one :rss_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='feeds'"
               has_one :api_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='api'"
               belongs_to :auth_source
               # Active non-anonymous users scope
               named_scope :active, :conditions => "#{User.table_name}.status = #{STATUS_ACTIVE}"
               acts_as_customizable
               attr_accessor :password, :password_confirmation
               attr_accessor :last_before_login_on
               # Prevents unauthorized assignments
               attr_protected :login, :admin, :password, :password_confirmation, :hashed_password
               validates_presence_of :login, :firstname, :lastname, :mail, :if => Proc.new { |user| !user.is_a?(AnonymousUser) }
               validates_uniqueness_of :login, :if => Proc.new { |user| !user.login.blank? }, :case_sensitive => false
               validates_uniqueness_of :mail, :if => Proc.new { |user| !user.mail.blank? }, :case_sensitive => false
               # Login must contain lettres, numbers, underscores only
               validates_format_of :login, :with => /^[a-z0-9_\-@\.]*$/i
               validates_length_of :login, :maximum => 30
-              validates_format_of :firstname, :lastname, :with => /^[\w\s\'\-\.]*$/i
               validates_length_of :firstname, :lastname, :maximum => 30
               validates_format_of :mail, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :allow_nil => true
               validates_length_of :mail, :maximum => 60, :allow_nil => true
               validates_confirmation_of :password, :allow_nil => true
               validates_inclusion_of :mail_notification, :in => MAIL_NOTIFICATION_OPTIONS.collect(&:first), :allow_blank => true
               def before_create
                 self.mail_notification = Setting.default_notification_option if self.mail_notification.blank?
                 true
               end
               def before_save
                 # update hashed_password if password was set
                 self.hashed_password = User.hash_password(self.password) if self.password && self.auth_source_id.blank?
               end
               def reload(*args)
                 @name = nil
                 super
               end
               def mail=(arg)
                 write_attribute(:mail, arg.to_s.strip)
               end
               def identity_url=(url)
                 if url.blank?
                   write_attribute(:identity_url, '')
                 else
                   begin
                     write_attribute(:identity_url, OpenIdAuthentication.normalize_identifier(url))
                   rescue OpenIdAuthentication::InvalidOpenId
                     # Invlaid url, don't save
                   end
                 end
                 self.read_attribute(:identity_url)
               end
               # Returns the user that matches provided login and password, or nil
               def self.try_to_login(login, password)
                 # Make sure no one can sign in with an empty password
                 return nil if password.to_s.empty?
                 user = find_by_login(login)
                 if user
                   # user is already in local database
                   return nil if !user.active?
                   if user.auth_source
                     # user has an external authentication method
                     return nil unless user.auth_source.authenticate(login, password)
                   else
                     # authentication with local password
                     return nil unless User.hash_password(password) == user.hashed_password
                   end
                 else
                   # user is not yet registered, try to authenticate with available sources
                   attrs = AuthSource.authenticate(login, password)
                   if attrs
                     user = new(attrs)
                     user.login = login
                     user.language = Setting.default_language
                     if user.save
                       user.reload
                       logger.info("User '#{user.login}' created from external auth source: #{user.auth_source.type} - #{user.auth_source.name}") if logger && user.auth_source
                     end
                   end
                 end
                 user.update_attribute(:last_login_on, Time.now) if user && !user.new_record?
                 user
               rescue => text
                 raise text
               end
               # Returns the user who matches the given autologin +key+ or nil
               def self.try_to_autologin(key)
                 tokens = Token.find_all_by_action_and_value('autologin', key)
                 # Make sure there's only 1 token that matches the key
                 if tokens.size == 1
                   token = tokens.first
                   if (token.created_on > Setting.autologin.to_i.day.ago) && token.user && token.user.active?
                     token.user.update_attribute(:last_login_on, Time.now)
                     token.user
                   end
                 end
               end
               # Return user's full name for display
               def name(formatter = nil)
                 if formatter
                   eval('"' + (USER_FORMATS[formatter] || USER_FORMATS[:firstname_lastname]) + '"')
                 else
                   @name ||= eval('"' + (USER_FORMATS[Setting.user_format] || USER_FORMATS[:firstname_lastname]) + '"')
                 end
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
               def registered?
                 self.status == STATUS_REGISTERED
               end
               def locked?
                 self.status == STATUS_LOCKED
               end
               def activate
                 self.status = STATUS_ACTIVE
               end
               def register
                 self.status = STATUS_REGISTERED
               end
               def lock
                 self.status = STATUS_LOCKED
               end
               def activate!
                 update_attribute(:status, STATUS_ACTIVE)
               end
               def register!
                 update_attribute(:status, STATUS_REGISTERED)
               end
               def lock!
                 update_attribute(:status, STATUS_LOCKED)
               end
               def check_password?(clear_password)
                 if auth_source_id.present?
                   auth_source.authenticate(self.login, clear_password)
                 else
                   User.hash_password(clear_password) == self.hashed_password
                 end
               end
               # Does the backend storage allow this user to change their password?
               def change_password_allowed?
                 return true if auth_source_id.blank?
                 return auth_source.allow_password_changes?
               end
               # Generate and set a random password.  Useful for automated user creation
               # Based on Token#generate_token_value
               #
               def random_password
                 chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
                 password = ''
 .times { |i| password << chars[rand(chars.size-1)] }
                 self.password = password
                 self.password_confirmation = password
                 self
               end
               def pref
                 self.preference ||= UserPreference.new(:user => self)
               end
               def time_zone
                 @time_zone ||= (self.pref.time_zone.blank? ? nil : ActiveSupport::TimeZone[self.pref.time_zone])
               end
               def wants_comments_in_reverse_order?
                 self.pref[:comments_sorting] == 'desc'
               end
               # Return user's RSS key (a 40 chars long string), used to access feeds
               def rss_key
                 token = self.rss_token || Token.create(:user => self, :action => 'feeds')
                 token.value
               end
               # Return user's API key (a 40 chars long string), used to access the API
               def api_key
                 token = self.api_token || self.create_api_token(:action => 'api')
                 token.value
               end
               # Return an array of project ids for which the user has explicitly turned mail notifications on
               def notified_projects_ids
                 @notified_projects_ids ||= memberships.select {|m| m.mail_notification?}.collect(&:project_id)
               end
               def notified_project_ids=(ids)
                 Member.update_all("mail_notification = #{connection.quoted_false}", ['user_id = ?', id])
                 Member.update_all("mail_notification = #{connection.quoted_true}", ['user_id = ? AND project_id IN (?)', id, ids]) if ids && !ids.empty?
                 @notified_projects_ids = nil
                 notified_projects_ids
               end
               # Only users that belong to more than 1 project can select projects for which they are notified
               def valid_notification_options
                 # Note that @user.membership.size would fail since AR ignores
                 # :include association option when doing a count
                 if memberships.length < 1
                   MAIL_NOTIFICATION_OPTIONS.delete_if {|option| option.first == 'selected'}
                 else
                   MAIL_NOTIFICATION_OPTIONS
                 end
               end
               # Find a user account by matching the exact login and then a case-insensitive
               # version.  Exact matches will be given priority.
               def self.find_by_login(login)
                 # force string comparison to be case sensitive on MySQL
                 type_cast = (ActiveRecord::Base.connection.adapter_name == 'MySQL') ? 'BINARY' : ''
                 # First look for an exact match
                 user = first(:conditions => ["#{type_cast} login = ?", login])
                 # Fail over to case-insensitive if none was found
                 user ||= first(:conditions => ["#{type_cast} LOWER(login) = ?", login.to_s.downcase])
               end
               def self.find_by_rss_key(key)
                 token = Token.find_by_value(key)
                 token && token.user.active? ? token.user : nil
               end
               def self.find_by_api_key(key)
                 token = Token.find_by_action_and_value('api', key)
                 token && token.user.active? ? token.user : nil
               end
               # Makes find_by_mail case-insensitive
               def self.find_by_mail(mail)
                 find(:first, :conditions => ["LOWER(mail) = ?", mail.to_s.downcase])
               end
               def to_s
                 name
               end
               # Returns the current day according to user's time zone
               def today
                 if time_zone.nil?
                   Date.today
                 else
                   Time.now.in_time_zone(time_zone).to_date
                 end
               end
               def logged?
                 true
               end
               def anonymous?
                 !logged?
               end
               # Return user's roles for project
               def roles_for_project(project)
                 roles = []
                 # No role on archived projects
                 return roles unless project && project.active?
                 if logged?
                   # Find project membership
                   membership = memberships.detect {|m| m.project_id == project.id}
                   if membership
                     roles = membership.roles
                   else
                     @role_non_member ||= Role.non_member
                     roles << @role_non_member
                   end
                 else
                   @role_anonymous ||= Role.anonymous
                   roles << @role_anonymous
                 end
                 roles
               end
               # Return true if the user is a member of project
               def member_of?(project)
                 !roles_for_project(project).detect {|role| role.member?}.nil?
               end
               # Return true if the user is allowed to do the specified action on a specific context
               # Action can be:
               # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
               # * a permission Symbol (eg. :edit_project)
               # Context can be:
               # * a project : returns true if user is allowed to do the specified action on this project
               # * a group of projects : returns true if user is allowed on every project
               # * nil with options[:global] set : check if user has at least one role allowed for this action,
               #   or falls back to Non Member / Anonymous permissions depending if the user is logged
               def allowed_to?(action, context, options={})
                 if context && context.is_a?(Project)
                   # No action allowed on archived projects
                   return false unless context.active?
                   # No action allowed on disabled modules
                   return false unless context.allows_to?(action)
                   # Admin users are authorized for anything else
                   return true if admin?
                   roles = roles_for_project(context)
                   return false unless roles
                   roles.detect {|role| (context.is_public? || role.member?) && role.allowed_to?(action)}
                 elsif context && context.is_a?(Array)
                   # Authorize if user is authorized on every element of the array
                   context.map do |project|
                     allowed_to?(action,project,options)
                   end.inject do |memo,allowed|
                     memo && allowed
                   end
                 elsif options[:global]
                   # Admin users are always authorized
                   return true if admin?
                   # authorize if user has at least one role that has this permission
                   roles = memberships.collect {|m| m.roles}.flatten.uniq
                   roles.detect {|r| r.allowed_to?(action)} || (self.logged? ? Role.non_member.allowed_to?(action) : Role.anonymous.allowed_to?(action))
                 else
                   false
                 end
               end
               # Is the user allowed to do the specified action on any project?
               # See allowed_to? for the actions and valid options.
               def allowed_to_globally?(action, options)
                 allowed_to?(action, nil, options.reverse_merge(:global => true))
               end
               safe_attributes 'login',
                 'firstname',
                 'lastname',
                 'mail',
                 'mail_notification',
                 'language',
                 'custom_field_values',
                 'custom_fields',
                 'identity_url'
               safe_attributes 'status',
                 'auth_source_id',
                 :if => lambda {|user, current_user| current_user.admin?}
               safe_attributes 'group_ids',
                 :if => lambda {|user, current_user| current_user.admin? && !user.new_record?}
               # Utility method to help check if a user should be notified about an
               # event.
               #
               # TODO: only supports Issue events currently
               def notify_about?(object)
                 case mail_notification
                 when 'all'
                   true
                 when 'selected'
                   # Handled by the Project
                 when 'none'
                   false
                 when 'only_my_events'
                   if object.is_a?(Issue) && (object.author == self || object.assigned_to == self)
                     true
                   else
                     false
                   end
                 when 'only_assigned'
                   if object.is_a?(Issue) && object.assigned_to == self
                     true
                   else
                     false
                   end
                 when 'only_owner'
                   if object.is_a?(Issue) && object.author == self
                     true
                   else
                     false
                   end
                 else
                   false
                 end
               end
               def self.current=(user)
                 @current_user = user
               end
               def self.current
                 @current_user ||= User.anonymous
               end
               # Returns the anonymous user.  If the anonymous user does not exist, it is created.  There can be only
               # one anonymous user per database.
               def self.anonymous
                 anonymous_user = AnonymousUser.find(:first)
                 if anonymous_user.nil?
                   anonymous_user = AnonymousUser.create(:lastname => 'Anonymous', :firstname => '', :mail => '', :login => '', :status => 0)
                   raise 'Unable to create the anonymous user.' if anonymous_user.new_record?
                 end
                 anonymous_user
               end
               protected
               def validate
                 # Password length validation based on setting
                 if !password.nil? && password.size < Setting.password_min_length.to_i
                   errors.add(:password, :too_short, :count => Setting.password_min_length.to_i)
                 end
               end
               private
               # Return password digest
               def self.hash_password(clear_password)
                 Digest::SHA1.hexdigest(clear_password || "")
               end
             end
             class AnonymousUser < User
               def validate_on_create
                 # There should be only one AnonymousUser in the database
                 errors.add_to_base 'An anonymous user already exists.' if AnonymousUser.find(:first)
               end
               def available_custom_fields
                 []
               end
               # Overrides a few properties
               def logged?; false end
               def admin; false end
               def name(*args); I18n.t(:label_user_anonymous) end
               def mail; nil end
               def time_zone; nil end
               def rss_key; nil end
             end

lib/tasks/migrate_from_mantis.rake +1 -3

             # 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 = IssuePriority.all
                   DEFAULT_PRIORITY = priorities[2]
                   PRIORITY_MAPPING = {10 => priorities[1], # none
 => priorities[1], # low
 => priorities[2], # normal
 => priorities[3], # high
 => priorities[4], # urgent
 => priorities[5]  # immediate
                                       }
                   TRACKER_BUG = Tracker.find_by_position(1)
                   TRACKER_FEATURE = Tracker.find_by_position(2)
                   roles = Role.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 identifier
                     read_attribute(:name).gsub(/[^a-z0-9\-]+/, '-').slice(0, Project::IDENTIFIER_MAX_LENGTH)
                   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(*args)
                   	if @read_finished
                   		nil
                   	else
                   		@read_finished = true
                   		content
                   	end
                   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\'\-]/, '-')
+                    read_attribute(:name)[0..29]
                   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]),
                 	                   :roles => [ROLE_MAPPING[member.access_level] || DEFAULT_ROLE]
                 	  m.project = p
                 	  m.save
                 	end
                 	# Project versions
                 	project.versions.each do |version|
                       v = Version.new :name => encode(version.version),
                                       :description => encode(version.description),
                                       :effective_date => version.date_order.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_each(:batch_size => 200) do |bug|
                     next unless projects_map[bug.project_id] && users_map[bug.reporter_id]
                 	i = Issue.new :project_id => projects_map[bug.project_id],
                                   :subject => encode(bug.summary),
                                   :description => encode(bug.bug_text.full_description),
                                   :priority => PRIORITY_MAPPING[bug.priority] || DEFAULT_PRIORITY,
                                   :created_on => bug.date_submitted,
                                   :updated_on => bug.last_updated
                 	i.author = User.find_by_id(users_map[bug.reporter_id])
                 	i.category = IssueCategory.find_by_project_id_and_name(i.project_id, bug.category[0,30]) unless bug.category.blank?
                 	i.fixed_version = Version.find_by_project_id_and_name(i.project_id, bug.fixed_in_version) unless bug.fixed_in_version.blank?
                 	i.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 '.'
                   STDOUT.flush
                     # Assignee
                     # Redmine checks that the assignee is a project member
                     if (bug.handler_id && users_map[bug.handler_id])
                       i.assigned_to = User.find_by_id(users_map[bug.handler_id])
                       i.save_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 '.'
                     STDOUT.flush
                   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 '.'
                     STDOUT.flush
                   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 '.'
                     STDOUT.flush
                     # 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] "
               STDOUT.flush
               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]: "
                 STDOUT.flush
                 encoding = STDIN.gets.chomp!
                 encoding = 'UTF-8' if encoding.blank?
                 break if MantisMigrate.encoding encoding
                 puts "Invalid encoding!"
               end
               puts
               # Make sure bugs can refer bugs in other projects
               Setting.cross_project_issue_relations = 1 if Setting.respond_to? 'cross_project_issue_relations'
               # Turn off email notifications
               Setting.notified_events = []
               MantisMigrate.establish_connection db_params
               MantisMigrate.migrate
             end
             end

lib/tasks/migrate_from_trac.rake +2 -2

             # 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 = IssuePriority.all
                     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
                       ''
                     end
                     def exist?
                       File.file? trac_fullpath
                     end
                     def open
                       File.open("#{trac_fullpath}", 'rb') {|f|
                         @file = f
                         yield self
                       }
                     end
                     def read(*args)
                       @file.read(*args)
                     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 = \'#{TracMigrate::TracAttachment.connection.quote_string(id.to_s)}\''
                     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 = \'#{TracMigrate::TracAttachment.connection.quote_string(id.to_s)}\''
                     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, '-'),
+                                   :firstname => fn[0, limit_for(User, 'firstname')],
-                                   :lastname => ln[0, limit_for(User, 'lastname')].gsub(/[^\w\s\'\-]/i, '-')
+                                   :lastname => ln[0, limit_for(User, 'lastname')]
                       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, :roles => [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_each(:batch_size => 200) 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?
                           attachment.open {
                             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
                           attachment.open {
                             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] "
                       STDOUT.flush
                       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
                     @target_project.reload
                   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] "
                 STDOUT.flush
                 break unless STDIN.gets.match(/^y$/i)
                 puts
                 def prompt(text, options = {}, &block)
                   default = options[:default] || ''
                   while true
                     print "#{text} [#{default}]: "
                     STDOUT.flush
                     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
                 # Turn off email notifications
                 Setting.notified_events = []
                 TracMigrate.migrate
               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