Added branch for sys controller refactoring.
git-svn-id: http://redmine.rubyforge.org/svn/branches/work@1006 e93f8b46-1217-0410-a6f0-8f06a7374b81
This commit is contained in:
Jean-Philippe Lang
@@ -0,0 +1,9 @@
|
||||
def deprecated_task(name, new_name)
|
||||
task name=>new_name do
|
||||
$stderr.puts "\nNote: The rake task #{name} has been deprecated, please use the replacement version #{new_name}"
|
||||
end
|
||||
end
|
||||
|
||||
deprecated_task :load_default_data, "redmine:load_default_data"
|
||||
deprecated_task :migrate_from_mantis, "redmine:migrate_from_mantis"
|
||||
deprecated_task :migrate_from_trac, "redmine:migrate_from_trac"
|
||||
@@ -0,0 +1,24 @@
|
||||
desc 'Create YAML test fixtures from data in an existing database.
|
||||
Defaults to development database. Set RAILS_ENV to override.'
|
||||
|
||||
task :extract_fixtures => :environment do
|
||||
sql = "SELECT * FROM %s"
|
||||
skip_tables = ["schema_info"]
|
||||
ActiveRecord::Base.establish_connection
|
||||
(ActiveRecord::Base.connection.tables - skip_tables).each do |table_name|
|
||||
i = "000"
|
||||
File.open("#{RAILS_ROOT}/#{table_name}.yml", 'w' ) do |file|
|
||||
data = ActiveRecord::Base.connection.select_all(sql % table_name)
|
||||
file.write data.inject({}) { |hash, record|
|
||||
|
||||
# cast extracted values
|
||||
ActiveRecord::Base.connection.columns(table_name).each { |col|
|
||||
record[col.name] = col.type_cast(record[col.name]) if record[col.name]
|
||||
}
|
||||
|
||||
hash["#{table_name}_#{i.succ!}"] = record
|
||||
hash
|
||||
}.to_yaml
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,168 @@
|
||||
desc 'Load Redmine default configuration data'
|
||||
|
||||
namespace :redmine do
|
||||
task :load_default_data => :environment do
|
||||
include GLoc
|
||||
set_language_if_valid('en')
|
||||
puts
|
||||
|
||||
while true
|
||||
print "Select language: "
|
||||
print GLoc.valid_languages.sort {|x,y| x.to_s <=> y.to_s }.join(", ")
|
||||
print " [#{GLoc.current_language}] "
|
||||
lang = STDIN.gets.chomp!
|
||||
break if lang.empty?
|
||||
break if set_language_if_valid(lang)
|
||||
puts "Unknown language!"
|
||||
end
|
||||
|
||||
puts "===================================="
|
||||
|
||||
begin
|
||||
# check that no data already exists
|
||||
if Role.find(:first, :conditions => {:builtin => 0})
|
||||
raise "Some roles are already defined."
|
||||
end
|
||||
if Tracker.find(:first)
|
||||
raise "Some trackers are already defined."
|
||||
end
|
||||
if IssueStatus.find(:first)
|
||||
raise "Some statuses are already defined."
|
||||
end
|
||||
if Enumeration.find(:first)
|
||||
raise "Some enumerations are already defined."
|
||||
end
|
||||
|
||||
puts "Loading default configuration data for language: #{current_language}"
|
||||
|
||||
# roles
|
||||
manager = Role.create :name => l(:default_role_manager),
|
||||
:position => 1
|
||||
manager.permissions = manager.setable_permissions.collect {|p| p.name}
|
||||
manager.save
|
||||
|
||||
developper = Role.create :name => l(:default_role_developper),
|
||||
:position => 2,
|
||||
:permissions => [:manage_versions,
|
||||
:manage_categories,
|
||||
:add_issues,
|
||||
:edit_issues,
|
||||
:manage_issue_relations,
|
||||
:add_issue_notes,
|
||||
:change_issue_status,
|
||||
:save_queries,
|
||||
:view_gantt,
|
||||
:view_calendar,
|
||||
:log_time,
|
||||
:view_time_entries,
|
||||
:comment_news,
|
||||
:view_documents,
|
||||
:view_wiki_pages,
|
||||
:edit_wiki_pages,
|
||||
:delete_wiki_pages,
|
||||
:add_messages,
|
||||
:view_files,
|
||||
:manage_files,
|
||||
:browse_repository,
|
||||
:view_changesets]
|
||||
|
||||
reporter = Role.create :name => l(:default_role_reporter),
|
||||
:position => 3,
|
||||
:permissions => [:add_issues,
|
||||
:add_issue_notes,
|
||||
:change_issue_status,
|
||||
:save_queries,
|
||||
:view_gantt,
|
||||
:view_calendar,
|
||||
:log_time,
|
||||
:view_time_entries,
|
||||
:comment_news,
|
||||
:view_documents,
|
||||
:view_wiki_pages,
|
||||
:add_messages,
|
||||
:view_files,
|
||||
:browse_repository,
|
||||
:view_changesets]
|
||||
|
||||
Role.non_member.update_attribute :permissions, [:add_issues,
|
||||
:add_issue_notes,
|
||||
:change_issue_status,
|
||||
:save_queries,
|
||||
:view_gantt,
|
||||
:view_calendar,
|
||||
:view_time_entries,
|
||||
:comment_news,
|
||||
:view_documents,
|
||||
:view_wiki_pages,
|
||||
:add_messages,
|
||||
:view_files,
|
||||
:browse_repository,
|
||||
:view_changesets]
|
||||
|
||||
Role.anonymous.update_attribute :permissions, [:view_gantt,
|
||||
:view_calendar,
|
||||
:view_time_entries,
|
||||
:view_documents,
|
||||
:view_wiki_pages,
|
||||
:view_files,
|
||||
:browse_repository,
|
||||
:view_changesets]
|
||||
|
||||
# trackers
|
||||
Tracker.create(:name => l(:default_tracker_bug), :is_in_chlog => true, :is_in_roadmap => false, :position => 1)
|
||||
Tracker.create(:name => l(:default_tracker_feature), :is_in_chlog => true, :is_in_roadmap => true, :position => 2)
|
||||
Tracker.create(:name => l(:default_tracker_support), :is_in_chlog => false, :is_in_roadmap => false, :position => 3)
|
||||
|
||||
# issue statuses
|
||||
new = IssueStatus.create(:name => l(:default_issue_status_new), :is_closed => false, :is_default => true, :position => 1)
|
||||
assigned = IssueStatus.create(:name => l(:default_issue_status_assigned), :is_closed => false, :is_default => false, :position => 2)
|
||||
resolved = IssueStatus.create(:name => l(:default_issue_status_resolved), :is_closed => false, :is_default => false, :position => 3)
|
||||
feedback = IssueStatus.create(:name => l(:default_issue_status_feedback), :is_closed => false, :is_default => false, :position => 4)
|
||||
closed = IssueStatus.create(:name => l(:default_issue_status_closed), :is_closed => true, :is_default => false, :position => 5)
|
||||
rejected = IssueStatus.create(:name => l(:default_issue_status_rejected), :is_closed => true, :is_default => false, :position => 6)
|
||||
|
||||
# workflow
|
||||
Tracker.find(:all).each { |t|
|
||||
IssueStatus.find(:all).each { |os|
|
||||
IssueStatus.find(:all).each { |ns|
|
||||
Workflow.create(:tracker_id => t.id, :role_id => manager.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Tracker.find(:all).each { |t|
|
||||
[new, assigned, resolved, feedback].each { |os|
|
||||
[assigned, resolved, feedback, closed].each { |ns|
|
||||
Workflow.create(:tracker_id => t.id, :role_id => developper.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Tracker.find(:all).each { |t|
|
||||
[new, assigned, resolved, feedback].each { |os|
|
||||
[closed].each { |ns|
|
||||
Workflow.create(:tracker_id => t.id, :role_id => reporter.id, :old_status_id => os.id, :new_status_id => ns.id) unless os == ns
|
||||
}
|
||||
}
|
||||
Workflow.create(:tracker_id => t.id, :role_id => reporter.id, :old_status_id => resolved.id, :new_status_id => feedback.id)
|
||||
}
|
||||
|
||||
# enumerations
|
||||
Enumeration.create(:opt => "DCAT", :name => l(:default_doc_category_user), :position => 1)
|
||||
Enumeration.create(:opt => "DCAT", :name => l(:default_doc_category_tech), :position => 2)
|
||||
|
||||
Enumeration.create(:opt => "IPRI", :name => l(:default_priority_low), :position => 1)
|
||||
Enumeration.create(:opt => "IPRI", :name => l(:default_priority_normal), :position => 2, :is_default => true)
|
||||
Enumeration.create(:opt => "IPRI", :name => l(:default_priority_high), :position => 3)
|
||||
Enumeration.create(:opt => "IPRI", :name => l(:default_priority_urgent), :position => 4)
|
||||
Enumeration.create(:opt => "IPRI", :name => l(:default_priority_immediate), :position => 5)
|
||||
|
||||
Enumeration.create(:opt => "ACTI", :name => l(:default_activity_design), :position => 1)
|
||||
Enumeration.create(:opt => "ACTI", :name => l(:default_activity_development), :position => 2)
|
||||
|
||||
rescue => error
|
||||
puts "Error: " + error
|
||||
puts "Default configuration data can't be loaded."
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,491 @@
|
||||
# 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
|
||||
20 => feedback_status, # feedback
|
||||
30 => DEFAULT_STATUS, # acknowledged
|
||||
40 => DEFAULT_STATUS, # confirmed
|
||||
50 => assigned_status, # assigned
|
||||
80 => resolved_status, # resolved
|
||||
90 => closed_status # closed
|
||||
}
|
||||
|
||||
priorities = Enumeration.get_values('IPRI')
|
||||
DEFAULT_PRIORITY = priorities[2]
|
||||
PRIORITY_MAPPING = {10 => priorities[1], # none
|
||||
20 => priorities[1], # low
|
||||
30 => priorities[2], # normal
|
||||
40 => priorities[3], # high
|
||||
50 => priorities[4], # urgent
|
||||
60 => 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
|
||||
25 => DEFAULT_ROLE, # reporter
|
||||
40 => DEFAULT_ROLE, # updater
|
||||
55 => developer_role, # developer
|
||||
70 => manager_role, # manager
|
||||
90 => manager_role # administrator
|
||||
}
|
||||
|
||||
CUSTOM_FIELD_TYPE_MAPPING = {0 => 'string', # String
|
||||
1 => 'int', # Numeric
|
||||
2 => 'int', # Float
|
||||
3 => 'list', # Enumeration
|
||||
4 => 'string', # Email
|
||||
5 => 'bool', # Checkbox
|
||||
6 => 'list', # List
|
||||
7 => 'list', # Multiselection list
|
||||
8 => 'date', # Date
|
||||
}
|
||||
|
||||
RELATION_TYPE_MAPPING = {1 => IssueRelation::TYPE_RELATES, # related to
|
||||
2 => IssueRelation::TYPE_RELATES, # parent of
|
||||
3 => IssueRelation::TYPE_RELATES, # child of
|
||||
0 => IssueRelation::TYPE_DUPLICATES, # duplicate of
|
||||
4 => IssueRelation::TYPE_DUPLICATES # has duplicate
|
||||
}
|
||||
|
||||
class MantisUser < ActiveRecord::Base
|
||||
set_table_name :mantis_user_table
|
||||
|
||||
def firstname
|
||||
realname.blank? ? username : realname.split.first[0..29]
|
||||
end
|
||||
|
||||
def lastname
|
||||
realname.blank? ? username : realname.split[1..-1].join(' ')[0..29]
|
||||
end
|
||||
|
||||
def email
|
||||
if read_attribute(:email).match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
|
||||
read_attribute(:email)
|
||||
else
|
||||
"#{username}@foo.bar"
|
||||
end
|
||||
end
|
||||
|
||||
def username
|
||||
read_attribute(:username)[0..29].gsub(/[^a-zA-Z0-9_\-@\.]/, '-')
|
||||
end
|
||||
end
|
||||
|
||||
class MantisProject < ActiveRecord::Base
|
||||
set_table_name :mantis_project_table
|
||||
has_many :versions, :class_name => "MantisVersion", :foreign_key => :project_id
|
||||
has_many :categories, :class_name => "MantisCategory", :foreign_key => :project_id
|
||||
has_many :news, :class_name => "MantisNews", :foreign_key => :project_id
|
||||
has_many :members, :class_name => "MantisProjectUser", :foreign_key => :project_id
|
||||
|
||||
def name
|
||||
read_attribute(:name)[0..29]
|
||||
end
|
||||
|
||||
def description
|
||||
read_attribute(:description).blank? ? read_attribute(:name) : read_attribute(:description)[0..254]
|
||||
end
|
||||
|
||||
def identifier
|
||||
read_attribute(:name).underscore[0..19].gsub(/[^a-z0-9\-]/, '-')
|
||||
end
|
||||
end
|
||||
|
||||
class MantisVersion < ActiveRecord::Base
|
||||
set_table_name :mantis_project_version_table
|
||||
|
||||
def version
|
||||
read_attribute(:version)[0..29]
|
||||
end
|
||||
|
||||
def description
|
||||
read_attribute(:description)[0..254]
|
||||
end
|
||||
end
|
||||
|
||||
class MantisCategory < ActiveRecord::Base
|
||||
set_table_name :mantis_project_category_table
|
||||
end
|
||||
|
||||
class MantisProjectUser < ActiveRecord::Base
|
||||
set_table_name :mantis_project_user_list_table
|
||||
end
|
||||
|
||||
class MantisBug < ActiveRecord::Base
|
||||
set_table_name :mantis_bug_table
|
||||
belongs_to :bug_text, :class_name => "MantisBugText", :foreign_key => :bug_text_id
|
||||
has_many :bug_notes, :class_name => "MantisBugNote", :foreign_key => :bug_id
|
||||
has_many :bug_files, :class_name => "MantisBugFile", :foreign_key => :bug_id
|
||||
has_many :bug_monitors, :class_name => "MantisBugMonitor", :foreign_key => :bug_id
|
||||
end
|
||||
|
||||
class MantisBugText < ActiveRecord::Base
|
||||
set_table_name :mantis_bug_text_table
|
||||
|
||||
# Adds Mantis steps_to_reproduce and additional_information fields
|
||||
# to description if any
|
||||
def full_description
|
||||
full_description = description
|
||||
full_description += "\n\n*Steps to reproduce:*\n\n#{steps_to_reproduce}" unless steps_to_reproduce.blank?
|
||||
full_description += "\n\n*Additional information:*\n\n#{additional_information}" unless additional_information.blank?
|
||||
full_description
|
||||
end
|
||||
end
|
||||
|
||||
class MantisBugNote < ActiveRecord::Base
|
||||
set_table_name :mantis_bugnote_table
|
||||
belongs_to :bug, :class_name => "MantisBug", :foreign_key => :bug_id
|
||||
belongs_to :bug_note_text, :class_name => "MantisBugNoteText", :foreign_key => :bugnote_text_id
|
||||
end
|
||||
|
||||
class MantisBugNoteText < ActiveRecord::Base
|
||||
set_table_name :mantis_bugnote_text_table
|
||||
end
|
||||
|
||||
class MantisBugFile < ActiveRecord::Base
|
||||
set_table_name :mantis_bug_file_table
|
||||
|
||||
def size
|
||||
filesize
|
||||
end
|
||||
|
||||
def original_filename
|
||||
filename
|
||||
end
|
||||
|
||||
def content_type
|
||||
file_type
|
||||
end
|
||||
|
||||
def read
|
||||
content
|
||||
end
|
||||
end
|
||||
|
||||
class MantisBugRelationship < ActiveRecord::Base
|
||||
set_table_name :mantis_bug_relationship_table
|
||||
end
|
||||
|
||||
class MantisBugMonitor < ActiveRecord::Base
|
||||
set_table_name :mantis_bug_monitor_table
|
||||
end
|
||||
|
||||
class MantisNews < ActiveRecord::Base
|
||||
set_table_name :mantis_news_table
|
||||
end
|
||||
|
||||
class MantisCustomField < ActiveRecord::Base
|
||||
set_table_name :mantis_custom_field_table
|
||||
set_inheritance_column :none
|
||||
has_many :values, :class_name => "MantisCustomFieldString", :foreign_key => :field_id
|
||||
has_many :projects, :class_name => "MantisCustomFieldProject", :foreign_key => :field_id
|
||||
|
||||
def format
|
||||
read_attribute :type
|
||||
end
|
||||
|
||||
def name
|
||||
read_attribute(:name)[0..29].gsub(/[^\w\s\'\-]/, '-')
|
||||
end
|
||||
end
|
||||
|
||||
class MantisCustomFieldProject < ActiveRecord::Base
|
||||
set_table_name :mantis_custom_field_project_table
|
||||
end
|
||||
|
||||
class MantisCustomFieldString < ActiveRecord::Base
|
||||
set_table_name :mantis_custom_field_string_table
|
||||
end
|
||||
|
||||
|
||||
def self.migrate
|
||||
|
||||
# Users
|
||||
print "Migrating users"
|
||||
User.delete_all "login <> 'admin'"
|
||||
users_map = {}
|
||||
users_migrated = 0
|
||||
MantisUser.find(:all).each do |user|
|
||||
u = User.new :firstname => encode(user.firstname),
|
||||
:lastname => encode(user.lastname),
|
||||
:mail => user.email,
|
||||
:last_login_on => user.last_visit
|
||||
u.login = user.username
|
||||
u.password = 'mantis'
|
||||
u.status = User::STATUS_LOCKED if user.enabled != 1
|
||||
u.admin = true if user.access_level == 90
|
||||
next unless u.save
|
||||
users_migrated += 1
|
||||
users_map[user.id] = u.id
|
||||
print '.'
|
||||
end
|
||||
puts
|
||||
|
||||
# Projects
|
||||
print "Migrating projects"
|
||||
Project.destroy_all
|
||||
projects_map = {}
|
||||
versions_map = {}
|
||||
categories_map = {}
|
||||
MantisProject.find(:all).each do |project|
|
||||
p = Project.new :name => encode(project.name),
|
||||
:description => encode(project.description)
|
||||
p.identifier = project.identifier
|
||||
next unless p.save
|
||||
projects_map[project.id] = p.id
|
||||
p.enabled_module_names = ['issue_tracking', 'news', 'wiki']
|
||||
p.trackers << TRACKER_BUG
|
||||
p.trackers << TRACKER_FEATURE
|
||||
print '.'
|
||||
|
||||
# Project members
|
||||
project.members.each do |member|
|
||||
m = Member.new :user => User.find_by_id(users_map[member.user_id]),
|
||||
:role => ROLE_MAPPING[member.access_level] || DEFAULT_ROLE
|
||||
m.project = p
|
||||
m.save
|
||||
end
|
||||
|
||||
# Project versions
|
||||
project.versions.each do |version|
|
||||
v = Version.new :name => encode(version.version),
|
||||
:description => encode(version.description),
|
||||
:effective_date => version.date_order.to_date
|
||||
v.project = p
|
||||
v.save
|
||||
versions_map[version.id] = v.id
|
||||
end
|
||||
|
||||
# Project categories
|
||||
project.categories.each do |category|
|
||||
g = IssueCategory.new :name => category.category[0,30]
|
||||
g.project = p
|
||||
g.save
|
||||
categories_map[category.category] = g.id
|
||||
end
|
||||
end
|
||||
puts
|
||||
|
||||
# Bugs
|
||||
print "Migrating bugs"
|
||||
Issue.destroy_all
|
||||
issues_map = {}
|
||||
MantisBug.find(:all).each do |bug|
|
||||
next unless projects_map[bug.project_id] && users_map[bug.reporter_id]
|
||||
i = Issue.new :project_id => projects_map[bug.project_id],
|
||||
:subject => encode(bug.summary),
|
||||
:description => encode(bug.bug_text.full_description),
|
||||
:priority => PRIORITY_MAPPING[bug.priority] || DEFAULT_PRIORITY,
|
||||
:created_on => bug.date_submitted,
|
||||
:updated_on => bug.last_updated
|
||||
i.author = User.find_by_id(users_map[bug.reporter_id])
|
||||
i.category = IssueCategory.find_by_project_id_and_name(i.project_id, bug.category[0,30]) unless bug.category.blank?
|
||||
i.fixed_version = Version.find_by_project_id_and_name(i.project_id, bug.fixed_in_version) unless bug.fixed_in_version.blank?
|
||||
i.status = STATUS_MAPPING[bug.status] || DEFAULT_STATUS
|
||||
i.tracker = (bug.severity == 10 ? TRACKER_FEATURE : TRACKER_BUG)
|
||||
next unless i.save
|
||||
issues_map[bug.id] = i.id
|
||||
print '.'
|
||||
|
||||
# Assignee
|
||||
# Redmine checks that the assignee is a project member
|
||||
if (bug.handler_id && users_map[bug.handler_id])
|
||||
i.assigned_to = User.find_by_id(users_map[bug.handler_id])
|
||||
i.save_with_validation(false)
|
||||
end
|
||||
|
||||
# Bug notes
|
||||
bug.bug_notes.each do |note|
|
||||
next unless users_map[note.reporter_id]
|
||||
n = Journal.new :notes => encode(note.bug_note_text.note),
|
||||
:created_on => note.date_submitted
|
||||
n.user = User.find_by_id(users_map[note.reporter_id])
|
||||
n.journalized = i
|
||||
n.save
|
||||
end
|
||||
|
||||
# Bug files
|
||||
bug.bug_files.each do |file|
|
||||
a = Attachment.new :created_on => file.date_added
|
||||
a.file = file
|
||||
a.author = User.find :first
|
||||
a.container = i
|
||||
a.save
|
||||
end
|
||||
|
||||
# Bug monitors
|
||||
bug.bug_monitors.each do |monitor|
|
||||
next unless users_map[monitor.user_id]
|
||||
i.add_watcher(User.find_by_id(users_map[monitor.user_id]))
|
||||
end
|
||||
end
|
||||
puts
|
||||
|
||||
# Bug relationships
|
||||
print "Migrating bug relations"
|
||||
MantisBugRelationship.find(:all).each do |relation|
|
||||
next unless issues_map[relation.source_bug_id] && issues_map[relation.destination_bug_id]
|
||||
r = IssueRelation.new :relation_type => RELATION_TYPE_MAPPING[relation.relationship_type]
|
||||
r.issue_from = Issue.find_by_id(issues_map[relation.source_bug_id])
|
||||
r.issue_to = Issue.find_by_id(issues_map[relation.destination_bug_id])
|
||||
pp r unless r.save
|
||||
print '.'
|
||||
end
|
||||
puts
|
||||
|
||||
# News
|
||||
print "Migrating news"
|
||||
News.destroy_all
|
||||
MantisNews.find(:all, :conditions => 'project_id > 0').each do |news|
|
||||
next unless projects_map[news.project_id]
|
||||
n = News.new :project_id => projects_map[news.project_id],
|
||||
:title => encode(news.headline[0..59]),
|
||||
:description => encode(news.body),
|
||||
:created_on => news.date_posted
|
||||
n.author = User.find_by_id(users_map[news.poster_id])
|
||||
n.save
|
||||
print '.'
|
||||
end
|
||||
puts
|
||||
|
||||
# Custom fields
|
||||
print "Migrating custom fields"
|
||||
IssueCustomField.destroy_all
|
||||
MantisCustomField.find(:all).each do |field|
|
||||
f = IssueCustomField.new :name => field.name[0..29],
|
||||
:field_format => CUSTOM_FIELD_TYPE_MAPPING[field.format],
|
||||
:min_length => field.length_min,
|
||||
:max_length => field.length_max,
|
||||
:regexp => field.valid_regexp,
|
||||
:possible_values => field.possible_values.split('|'),
|
||||
:is_required => field.require_report?
|
||||
next unless f.save
|
||||
print '.'
|
||||
|
||||
# Trackers association
|
||||
f.trackers = Tracker.find :all
|
||||
|
||||
# Projects association
|
||||
field.projects.each do |project|
|
||||
f.projects << Project.find_by_id(projects_map[project.project_id]) if projects_map[project.project_id]
|
||||
end
|
||||
|
||||
# Values
|
||||
field.values.each do |value|
|
||||
v = CustomValue.new :custom_field_id => f.id,
|
||||
:value => value.value
|
||||
v.customized = Issue.find_by_id(issues_map[value.bug_id]) if issues_map[value.bug_id]
|
||||
v.save
|
||||
end unless f.new_record?
|
||||
end
|
||||
puts
|
||||
|
||||
puts
|
||||
puts "Users: #{users_migrated}/#{MantisUser.count}"
|
||||
puts "Projects: #{Project.count}/#{MantisProject.count}"
|
||||
puts "Memberships: #{Member.count}/#{MantisProjectUser.count}"
|
||||
puts "Versions: #{Version.count}/#{MantisVersion.count}"
|
||||
puts "Categories: #{IssueCategory.count}/#{MantisCategory.count}"
|
||||
puts "Bugs: #{Issue.count}/#{MantisBug.count}"
|
||||
puts "Bug notes: #{Journal.count}/#{MantisBugNote.count}"
|
||||
puts "Bug files: #{Attachment.count}/#{MantisBugFile.count}"
|
||||
puts "Bug relations: #{IssueRelation.count}/#{MantisBugRelationship.count}"
|
||||
puts "Bug monitors: #{Watcher.count}/#{MantisBugMonitor.count}"
|
||||
puts "News: #{News.count}/#{MantisNews.count}"
|
||||
puts "Custom fields: #{IssueCustomField.count}/#{MantisCustomField.count}"
|
||||
end
|
||||
|
||||
def self.encoding(charset)
|
||||
@ic = Iconv.new('UTF-8', charset)
|
||||
rescue Iconv::InvalidEncoding
|
||||
return false
|
||||
end
|
||||
|
||||
def self.establish_connection(params)
|
||||
constants.each do |const|
|
||||
klass = const_get(const)
|
||||
next unless klass.respond_to? 'establish_connection'
|
||||
klass.establish_connection params
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
def self.encode(text)
|
||||
@ic.iconv text
|
||||
rescue
|
||||
text
|
||||
end
|
||||
end
|
||||
|
||||
puts
|
||||
puts "WARNING: Your Redmine data will be deleted during this process."
|
||||
print "Are you sure you want to continue ? [y/N] "
|
||||
break unless STDIN.gets.match(/^y$/i)
|
||||
|
||||
# Default Mantis database settings
|
||||
db_params = {:adapter => 'mysql',
|
||||
:database => 'bugtracker',
|
||||
:host => 'localhost',
|
||||
:username => 'root',
|
||||
:password => '' }
|
||||
|
||||
puts
|
||||
puts "Please enter settings for your Mantis database"
|
||||
[:adapter, :host, :database, :username, :password].each do |param|
|
||||
print "#{param} [#{db_params[param]}]: "
|
||||
value = STDIN.gets.chomp!
|
||||
db_params[param] = value unless value.blank?
|
||||
end
|
||||
|
||||
while true
|
||||
print "encoding [UTF-8]: "
|
||||
encoding = STDIN.gets.chomp!
|
||||
encoding = 'UTF-8' if encoding.blank?
|
||||
break if MantisMigrate.encoding encoding
|
||||
puts "Invalid encoding!"
|
||||
end
|
||||
puts
|
||||
|
||||
# Make sure bugs can refer bugs in other projects
|
||||
Setting.cross_project_issue_relations = 1 if Setting.respond_to? 'cross_project_issue_relations'
|
||||
|
||||
MantisMigrate.establish_connection db_params
|
||||
MantisMigrate.migrate
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,555 @@
|
||||
# redMine - project management software
|
||||
# Copyright (C) 2006-2007 Jean-Philippe Lang
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
require 'active_record'
|
||||
require 'iconv'
|
||||
require 'pp'
|
||||
|
||||
namespace :redmine do
|
||||
desc 'Trac migration script'
|
||||
task :migrate_from_trac => :environment do
|
||||
|
||||
module TracMigrate
|
||||
TICKET_MAP = []
|
||||
|
||||
DEFAULT_STATUS = IssueStatus.default
|
||||
assigned_status = IssueStatus.find_by_position(2)
|
||||
resolved_status = IssueStatus.find_by_position(3)
|
||||
feedback_status = IssueStatus.find_by_position(4)
|
||||
closed_status = IssueStatus.find :first, :conditions => { :is_closed => true }
|
||||
STATUS_MAPPING = {'new' => DEFAULT_STATUS,
|
||||
'reopened' => feedback_status,
|
||||
'assigned' => assigned_status,
|
||||
'closed' => closed_status
|
||||
}
|
||||
|
||||
priorities = Enumeration.get_values('IPRI')
|
||||
DEFAULT_PRIORITY = priorities[0]
|
||||
PRIORITY_MAPPING = {'lowest' => priorities[0],
|
||||
'low' => priorities[0],
|
||||
'normal' => priorities[1],
|
||||
'high' => priorities[2],
|
||||
'highest' => priorities[3]
|
||||
}
|
||||
|
||||
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 TracComponent < ActiveRecord::Base
|
||||
set_table_name :component
|
||||
end
|
||||
|
||||
class TracMilestone < ActiveRecord::Base
|
||||
set_table_name :milestone
|
||||
|
||||
def due
|
||||
if read_attribute(:due) > 0
|
||||
Time.at(read_attribute(:due)).to_date
|
||||
else
|
||||
nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class TracTicketCustom < ActiveRecord::Base
|
||||
set_table_name :ticket_custom
|
||||
end
|
||||
|
||||
class TracAttachment < ActiveRecord::Base
|
||||
set_table_name :attachment
|
||||
set_inheritance_column :none
|
||||
|
||||
def time; Time.at(read_attribute(:time)) end
|
||||
|
||||
def original_filename
|
||||
filename
|
||||
end
|
||||
|
||||
def content_type
|
||||
Redmine::MimeType.of(filename) || ''
|
||||
end
|
||||
|
||||
def exist?
|
||||
File.file? trac_fullpath
|
||||
end
|
||||
|
||||
def read
|
||||
File.open("#{trac_fullpath}", 'rb').read
|
||||
end
|
||||
|
||||
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", :foreign_key => :id, :conditions => "#{TracMigrate::TracAttachment.table_name}.type = 'ticket'"
|
||||
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
|
||||
end
|
||||
|
||||
class TracTicketChange < ActiveRecord::Base
|
||||
set_table_name :ticket_change
|
||||
|
||||
def time; Time.at(read_attribute(:time)) end
|
||||
end
|
||||
|
||||
class TracWikiPage < ActiveRecord::Base
|
||||
set_table_name :wiki
|
||||
|
||||
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
|
||||
end
|
||||
|
||||
class TracPermission < ActiveRecord::Base
|
||||
set_table_name :permission
|
||||
end
|
||||
|
||||
def self.find_or_create_user(username, project_member = false)
|
||||
u = User.find_by_login(username)
|
||||
if !u
|
||||
# Create a new user if not found
|
||||
mail = username[0,limit_for(User, 'mail')]
|
||||
mail = "#{mail}@foo.bar" unless mail.include?("@")
|
||||
u = User.new :firstname => username[0,limit_for(User, 'firstname')].gsub(/[^\w\s\'\-]/i, '-'),
|
||||
:lastname => '-',
|
||||
:mail => mail.gsub(/[^-@a-z0-9\.]/i, '-')
|
||||
u.login = username[0,limit_for(User, 'login')].gsub(/[^a-z0-9_\-@\.]/i, '-')
|
||||
u.password = 'trac'
|
||||
u.admin = true if TracPermission.find_by_username_and_action(username, 'admin')
|
||||
# finally, a default user is used if the new user is not valid
|
||||
u = User.find(:first) unless u.save
|
||||
end
|
||||
# Make sure he is a member of the project
|
||||
if project_member && !u.member_of?(@target_project)
|
||||
role = DEFAULT_ROLE
|
||||
if u.admin
|
||||
role = ROLE_MAPPING['admin']
|
||||
elsif TracPermission.find_by_username_and_action(username, 'developer')
|
||||
role = ROLE_MAPPING['developer']
|
||||
end
|
||||
Member.create(:user => u, :project => @target_project, :role => role)
|
||||
u.reload
|
||||
end
|
||||
u
|
||||
end
|
||||
|
||||
# Basic wiki syntax conversion
|
||||
def self.convert_wiki_text(text)
|
||||
# Titles
|
||||
text = text.gsub(/^(\=+)\s(.+)\s(\=+)/) {|s| "\nh#{$1.length}. #{$2}\n"}
|
||||
# External Links
|
||||
text = text.gsub(/\[(http[^\s]+)\s+([^\]]+)\]/) {|s| "\"#{$2}\":#{$1}"}
|
||||
# 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(',./?;|:')}]]"}
|
||||
# Revisions links
|
||||
text = text.gsub(/\[(\d+)\]/, 'r\1')
|
||||
# Ticket number re-writing
|
||||
text = text.gsub(/#(\d+)/) do |s|
|
||||
TICKET_MAP[$1.to_i] ||= $1
|
||||
"\##{TICKET_MAP[$1.to_i] || $1}"
|
||||
end
|
||||
# Preformatted blocks
|
||||
text = text.gsub(/\{\{\{/, '<pre>')
|
||||
text = text.gsub(/\}\}\}/, '</pre>')
|
||||
# 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
|
||||
|
||||
# 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
|
||||
v = Version.new :project => @target_project,
|
||||
:name => encode(milestone.name[0, limit_for(Version, 'name')]),
|
||||
:description => encode(milestone.description.to_s[0, limit_for(Version, 'description')]),
|
||||
:effective_date => milestone.due
|
||||
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 = %w(fixed invalid wontfix duplicate worksforme)
|
||||
custom_field_map['resolution'] = r if r.save
|
||||
|
||||
# Tickets
|
||||
print "Migrating tickets"
|
||||
TracTicket.find(:all, :order => 'id ASC').each do |ticket|
|
||||
print '.'
|
||||
STDOUT.flush
|
||||
i = Issue.new :project => @target_project,
|
||||
:subject => encode(ticket.summary[0, limit_for(Issue, 'subject')]),
|
||||
:description => convert_wiki_text(encode(ticket.description)),
|
||||
:priority => PRIORITY_MAPPING[ticket.priority] || DEFAULT_PRIORITY,
|
||||
:created_on => ticket.time
|
||||
i.author = find_or_create_user(ticket.reporter)
|
||||
i.category = issues_category_map[ticket.component] unless ticket.component.blank?
|
||||
i.fixed_version = version_map[ticket.milestone] unless ticket.milestone.blank?
|
||||
i.status = STATUS_MAPPING[ticket.status] || DEFAULT_STATUS
|
||||
i.tracker = TRACKER_MAPPING[ticket.ticket_type] || DEFAULT_TRACKER
|
||||
i.custom_values << CustomValue.new(:custom_field => custom_field_map['resolution'], :value => ticket.resolution) unless ticket.resolution.blank?
|
||||
i.id = ticket.id unless Issue.exists?(ticket.id)
|
||||
next unless 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)
|
||||
i.save
|
||||
end
|
||||
|
||||
# Comments and status/resolution changes
|
||||
ticket.changes.group_by(&:time).each do |time, changeset|
|
||||
status_change = changeset.select {|change| change.field == 'status'}.first
|
||||
resolution_change = changeset.select {|change| change.field == 'resolution'}.first
|
||||
comment_change = changeset.select {|change| change.field == 'comment'}.first
|
||||
|
||||
n = Journal.new :notes => (comment_change ? convert_wiki_text(encode(comment_change.newvalue)) : ''),
|
||||
:created_on => time
|
||||
n.user = find_or_create_user(changeset.first.author)
|
||||
n.journalized = i
|
||||
if status_change &&
|
||||
STATUS_MAPPING[status_change.oldvalue] &&
|
||||
STATUS_MAPPING[status_change.newvalue] &&
|
||||
(STATUS_MAPPING[status_change.oldvalue] != STATUS_MAPPING[status_change.newvalue])
|
||||
n.details << JournalDetail.new(:property => 'attr',
|
||||
:prop_key => 'status_id',
|
||||
:old_value => STATUS_MAPPING[status_change.oldvalue].id,
|
||||
:value => STATUS_MAPPING[status_change.newvalue].id)
|
||||
end
|
||||
if resolution_change
|
||||
n.details << JournalDetail.new(:property => 'cf',
|
||||
:prop_key => custom_field_map['resolution'].id,
|
||||
:old_value => resolution_change.oldvalue,
|
||||
:value => resolution_change.newvalue)
|
||||
end
|
||||
n.save unless n.details.empty? && n.notes.blank?
|
||||
end
|
||||
|
||||
# Attachments
|
||||
ticket.attachments.each do |attachment|
|
||||
next unless attachment.exist?
|
||||
a = Attachment.new :created_on => attachment.time
|
||||
a.file = attachment
|
||||
a.author = find_or_create_user(attachment.author)
|
||||
a.container = i
|
||||
migrated_ticket_attachments += 1 if a.save
|
||||
end
|
||||
|
||||
# Custom fields
|
||||
ticket.customs.each do |custom|
|
||||
next if custom_field_map[custom.name].nil?
|
||||
v = CustomValue.new :custom_field => custom_field_map[custom.name],
|
||||
:value => custom.value
|
||||
v.customized = i
|
||||
next unless v.save
|
||||
migrated_custom_values += 1
|
||||
end
|
||||
end
|
||||
puts
|
||||
|
||||
# Wiki
|
||||
print "Migrating wiki"
|
||||
@target_project.wiki.destroy if @target_project.wiki
|
||||
@target_project.reload
|
||||
wiki = Wiki.new(:project => @target_project, :start_page => 'WikiStart')
|
||||
if wiki.save
|
||||
TracWikiPage.find(:all, :order => 'name, version').each do |page|
|
||||
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
|
||||
p.new_record? ? p.save : p.content.save
|
||||
migrated_wiki_edits += 1 unless p.content.new_record?
|
||||
end
|
||||
|
||||
wiki.reload
|
||||
wiki.pages.each do |page|
|
||||
page.content.text = convert_wiki_text(page.content.text)
|
||||
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("type = 'ticket'").to_s
|
||||
puts "Custom values: #{migrated_custom_values}/#{TracTicketCustom.count}"
|
||||
puts "Wiki edits: #{migrated_wiki_edits}/#{TracWikiPage.count}"
|
||||
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
|
||||
|
||||
mattr_reader :trac_directory, :trac_adapter, :trac_db_host, :trac_db_port, :trac_db_name, :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 => identifier.humanize
|
||||
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']
|
||||
end
|
||||
project.trackers << TRACKER_BUG
|
||||
project.trackers << TRACKER_FEATURE
|
||||
@target_project = project.new_record? ? nil : project
|
||||
end
|
||||
|
||||
def self.connection_params
|
||||
if %w(sqlite sqlite3).include?(trac_adapter)
|
||||
{:adapter => trac_adapter,
|
||||
:database => trac_db_path}
|
||||
else
|
||||
{:adapter => trac_adapter,
|
||||
:database => trac_db_name,
|
||||
:host => trac_db_host,
|
||||
:port => trac_db_port,
|
||||
:username => trac_db_username,
|
||||
:password => trac_db_password}
|
||||
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
|
||||
puts "WARNING: a new project will be added to Redmine during this process."
|
||||
print "Are you sure you want to continue ? [y/N] "
|
||||
break unless STDIN.gets.match(/^y$/i)
|
||||
puts
|
||||
|
||||
def prompt(text, options = {}, &block)
|
||||
default = options[:default] || ''
|
||||
while true
|
||||
print "#{text} [#{default}]: "
|
||||
value = STDIN.gets.chomp!
|
||||
value = default if value.blank?
|
||||
break if yield value
|
||||
end
|
||||
end
|
||||
|
||||
DEFAULT_PORTS = {'mysql' => 3306, 'postgresl' => 5432}
|
||||
|
||||
prompt('Trac directory') {|directory| TracMigrate.set_trac_directory directory}
|
||||
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 username') {|username| TracMigrate.set_trac_db_username username}
|
||||
prompt('Trac database password') {|password| TracMigrate.set_trac_db_password password}
|
||||
end
|
||||
prompt('Trac database encoding', :default => 'UTF-8') {|encoding| TracMigrate.encoding encoding}
|
||||
prompt('Target project identifier') {|identifier| TracMigrate.target_project_identifier identifier}
|
||||
puts
|
||||
|
||||
TracMigrate.migrate
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,15 @@
|
||||
namespace :db do
|
||||
desc 'Migrates installed plugins.'
|
||||
task :migrate_plugins => :environment do
|
||||
if Rails.respond_to?('plugins')
|
||||
Rails.plugins.each do |plugin|
|
||||
next unless plugin.respond_to?('migrate')
|
||||
puts "Migrating #{plugin.name}..."
|
||||
plugin.migrate
|
||||
end
|
||||
else
|
||||
puts "Undefined method plugins for Rails!"
|
||||
puts "Make sure engines plugin is installed."
|
||||
end
|
||||
end
|
||||
end
|
||||
Reference in New Issue
Block a user