Redmine

#!/usr/local/bin/ruby

#

# Copyright (c) 2009, Ralph Juhnke

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without modification, 

# are permitted provided that the following conditions are met:

#

#    1. Redistributions of source code must retain the above copyright notice, 

#       this list of conditions and the following disclaimer.

#    2. Redistributions in binary form must reproduce the above copyright notice, 

#       this list of conditions and the following disclaimer in the documentation and/or other

#       materials provided with the distribution.

# 

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 

# EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 

# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 

# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 

# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 

# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 

# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# 

require "rubygems"

require "mysql"

require "settings"

class ConnectionInfo

  attr_accessor :host

  attr_accessor :user

  attr_accessor :password

  attr_accessor :dbname

  def initialize(host, user, password, dbname)

    @host = host

    @user = user

    @password = password

    @dbname = dbname

  end

end

class BugzillaToRedmine

  def initialize

    @bugzillainfo =  ConnectionInfo.new(BUGZILLA_HOST, BUGZILLA_USER, BUGZILLA_PASSWORD, BUGZILLA_DB)

    @redmineinfo = ConnectionInfo.new(REDMINE_HOST, REDMINE_USER, REDMINE_PASSWORD, REDMINE_DB)

    # Bugzilla priority to Redmine priority map

    @issuePriorities = ISSUE_PRIORITIES

    # Bugzilla severity to Redmine tracker map

    @issueTrackers = ISSUE_TRACKERS

    # Bugzilla status to Redmine status map

    @issueStatus = ISSUE_STATUS 

  end

  def migrate

    self.open_connections

    self.clear_redmine_tables

    self.migrate_projects

    self.migrate_versions

    self.migrate_users

        self.migrate_groups

    self.migrate_members

        self.migrate_member_roles

        self.migrate_groups_users

        self.migrate_categories

    self.migrate_issues

        self.migrate_watchers

    self.migrate_issue_relations

    self.migrate_attachments

    self.close_connections

  end

  def open_connections

    @bugzilladb = self.open_connection(@bugzillainfo)

    @redminedb = self.open_connection(@redmineinfo)

  end

  def close_connections

    self.log "closing database connections"

    @bugzilladb.close

    @redminedb.close

  end

  def         open_connection(info)

    self.log "opening #{info.inspect}"

    return Mysql::new(info.host, info.user, info.password, info.dbname)

  end

  def clear_redmine_tables

    sqls = [

      "DELETE FROM projects",

      "DELETE FROM projects_trackers",

      "DELETE FROM enabled_modules",

      "DELETE FROM boards",

      "DELETE FROM custom_fields_projects",

      "DELETE FROM documents",

      "DELETE FROM news",

      "DELETE FROM queries",

      "DELETE FROM repositories",

      "DELETE FROM time_entries",

      "DELETE FROM wiki_content_versions",

      "DELETE FROM wiki_contents",

      "DELETE FROM wiki_pages",

      "DELETE FROM wiki_redirects",

      "DELETE FROM wikis",

    ]

    sqls.each do |sql|

      self.red_exec_sql(sql)

    end

  end

  def log(s)

    puts s

  end

  def migrate_projects

    self.bz_select_sql("SELECT products.id, products.name, products.description, products.classification_id, products.disallownew, classifications.name as classification_name FROM products, classifications WHERE products.classification_id = classifications.id") do |row|

      identifier = row[1].downcase

      status = row[3] == 1 ? 9 : 1

      created_at = self.find_min_created_at_for_product(row[0])

      updated_at = self.find_max_bug_when_for_product(row[0])

      self.red_exec_sql("INSERT INTO projects (id, name, description, is_public, identifier, created_on, updated_on, status) values (?, ?, ?, ?, ?, ?, ?, ?)", row[0], row[1], row[2], 1, identifier,

        created_at, updated_at, status)

      self.insert_project_trackers(row[0])

      self.insert_project_modules(row[0])

    end

  end

  def find_min_created_at_for_product(product_id)

    bug_when = '1970-01-01 10:22:25'

    sql = "select min(b.creation_ts) from products p join bugs b on b.product_id = p.id where product_id=?"

    self.bz_select_sql(sql, product_id) do |row|

      bug_when = row[0]

    end

    return bug_when

  end

  def find_max_bug_when_for_product(product_id)

    bug_when = '1970-01-01 10:22:25'

    sql = "select max(l.bug_when) from products p join bugs b on b.product_id = p.id join longdescs l on l.bug_id = b.bug_id where b.product_id=?"

    self.bz_select_sql(sql, product_id) do |row|

      bug_when = row[0]

    end

    return bug_when

  end

  def migrate_versions

    self.red_exec_sql("delete from versions")

    self.bz_select_sql("SELECT id, product_id AS project_id, value AS name FROM milestones") do |row|

      self.red_exec_sql("INSERT INTO versions (id, project_id, name) VALUES (?, ?, ?)", row[0], row[1], row[2])

    end

  end

  def migrate_users

    ["DELETE FROM users",

      "DELETE FROM user_preferences",

      "DELETE FROM members",

      "DELETE FROM member_roles",          

      "DELETE FROM groups_users",                    

      "DELETE FROM messages",     

      "DELETE FROM tokens",

      "DELETE FROM watchers"].each do |sql|

      self.red_exec_sql(sql)

    end

    self.bz_select_sql("SELECT userid, login_name, realname, disabledtext FROM profiles") do |row|

      user_id = row[0]

      login_name = row[1]

      real_name = row[2]

      disabled_text = row[3]

      if real_name.nil? 

        (last_name, first_name) = ['empty', 'empty']

      else

        (last_name, first_name) = real_name.split(/[ ]+/)

        if first_name.to_s.strip.empty?

          first_name = 'empty'

        end

      end

      status = disabled_text.to_s.strip.empty? ? 1 : 3

      self.red_exec_sql("INSERT INTO users (id, login, mail, firstname, lastname, language, mail_notification, status, hashed_password, type) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",

        user_id, login_name, login_name, last_name, first_name, 'en', 0, status, 'd033e22ae348aeb5660fc2140aec35850c4da997', 'User')

      other = """---

:comments_sorting: asc

:no_self_notified: true

      """

      self.red_exec_sql("INSERT INTO user_preferences (user_id,others) values (?, ?)", user_id, other)

    end

  end

  def migrate_groups

    self.bz_select_sql("select name from groups") do |row|

      name = row[0]

      self.red_exec_sql("insert into users (lastname, mail_notification, admin, status, type, language) values (?, ?, ?, ?, ?, ?)",

        name, 1, 0, 1, 'Group', 'en')

    end

  end

  def find_version_id(project_id, version)

    result = -1

    self.red_select_sql("select id from versions where project_id=? and name=?", project_id, version) do |row|

      result = row[0]

    end

    return result

  end

  def find_max_bug_when(bug_id)

    bug_when = '1970-01-01 10:22:25'

    self.bz_select_sql("select max(bug_when) from longdescs where bug_id=?", bug_id) do |row|

      bug_when = row[0]

    end

    return bug_when

  end

  def migrate_categories

    self.red_exec_sql("delete from issue_categories")

    self.bz_select_sql("SELECT id, name, product_id AS project_id, initialowner AS assigned_to_id FROM components") do |row|

      self.red_exec_sql("INSERT INTO issue_categories (id, name, project_id, assigned_to_id) VALUES (?, ?, ?, ?)", row[0], row[1], row[2], row[3])

    end

  end

  def migrate_watchers

    self.red_exec_sql("delete from watchers")

    self.bz_select_sql("select bug_id, who FROM cc") do |row|

      self.red_exec_sql("insert into watchers (watchable_type, watchable_id, user_id) values (?, ?, ?)", 'Issue', row[0], row[1])

    end

  end

  def insert_custom_fields

        self.red_exec_sql("delete from custom_fields")

        self.red_exec_sql("delete from custom_fields_trackers")

        self.red_exec_sql("delete from custom_values")        

        self.red_exec_sql("INSERT INTO custom_fields (id, type, name, field_format, possible_values, max_length, is_for_all, is_filter, searchable, default_value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", 1, 'IssueCustomField', 'URL', 'string', '--- []/n/n', 255, 1, 1, 1, '')

        [1,2,3].each do |tracker_id|

      self.red_exec_sql("INSERT INTO custom_fields_trackers (custom_field_id, tracker_id) VALUES (?, ?)", 1, tracker_id)

    end

  end

  def migrate_issues

    self.red_exec_sql("delete from issues")

    self.red_exec_sql("delete from journals")

        self.insert_custom_fields

    sql = "SELECT bugs.bug_id,

                       bugs.assigned_to,

                       bugs.bug_status,

                       bugs.creation_ts,

                       bugs.short_desc,

                       bugs.product_id,

                       bugs.reporter,

                       bugs.version,

                       bugs.resolution,

                       bugs.estimated_time,

                       bugs.remaining_time,

                       bugs.deadline,

                           bugs.target_milestone,

                       bugs.bug_severity,

                       bugs.priority,

                       bugs.component_id,

                       bugs.status_whiteboard AS whiteboard,

                       bugs.bug_file_loc AS url,

                       longdescs.comment_id,

                       longdescs.thetext,

                       longdescs.bug_when,

                       longdescs.who,

                       longdescs.isprivate

                   FROM bugs, longdescs

                   WHERE bugs.bug_id = longdescs.bug_id

                   ORDER BY bugs.bug_id, longdescs.bug_when"

    current_bug_id = -1

    self.bz_select_sql(sql) do |row|

      ( bug_id,

        assigned_to,

        bug_status,

        creation_ts,

        short_desc,

        product_id,

        reporter,

        version,

        resolution,

        estimated_time,

        remaining_time,

        deadline,

                target_milestone,

        bug_severity,

        priority,

        component_id,

        whiteboard,

        url,

        comment_id,

        thetext,

        bug_when,

        who,

        isprivate) = row

      if(current_bug_id != bug_id)

        sql = "INSERT INTO issues (id, project_id, subject, description, assigned_to_id, author_id, created_on, updated_on, start_date, estimated_hours, priority_id, fixed_version_id, category_id, tracker_id, status_id) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"

        status_id = 1

        version_id = self.find_version_id(product_id, version)

                target_milestone_id = self.find_version_id(product_id, target_milestone)

        updated_at = self.find_max_bug_when(bug_id)

        priority_id = @issuePriorities[priority]

        tracker_id = @issueTrackers[bug_severity]

        status_id = @issueStatus[bug_status]

        self.red_exec_sql(sql, bug_id, product_id, short_desc, thetext, assigned_to, reporter, creation_ts,  updated_at, creation_ts, estimated_time, priority_id, target_milestone_id, component_id, tracker_id,  status_id)

        current_bug_id = bug_id

                sql = "INSERT INTO custom_values (customized_type, customized_id, custom_field_id, value)  VALUES (?, ?, ?, ?)"

                self.red_exec_sql(sql, 'Issue', bug_id, 1, url)

      else

        sql = "INSERT INTO journals (id, journalized_id, journalized_type, user_id, notes, created_on)  VALUES (?, ?, ?, ?, ?, ?)"

        self.red_exec_sql(sql, comment_id, bug_id, "Issue", who, thetext, bug_when)

      end

    end

  end

  def migrate_issue_relations

    self.red_exec_sql("delete from issue_relations")

    sql = "SELECT dependson, blocked FROM dependencies"

    self.bz_select_sql(sql) do |row|

      self.red_exec_sql("INSERT INTO issue_relations (issue_from_id, issue_to_id, relation_type) values (?, ?, ?)", row[0], row[1], "blocks")

    end

    sql = "SELECT dupe, dupe_of FROM duplicates"

    self.bz_select_sql(sql) do |row|

      self.red_exec_sql("INSERT INTO issue_relations (issue_from_id, issue_to_id, relation_type) values (?, ?, ?)", row[0], row[1], "duplicates")

    end

  end

  def migrate_attachments

    self.red_exec_sql("DELETE FROM attachments")

    sql = "SELECT attachments.attach_id, attachments.bug_id, attachments.filename, attachments.mimetype, attachments.submitter_id, attachments.creation_ts, attachments.description, attach_data.thedata FROM attachments, attach_data WHERE attachments.attach_id = attach_data.id"

    self.bz_select_sql(sql) do |row|

      (attach_id, bug_id, filename, mimetype, submitter_id, creation_ts, description, thedata ) = row

      disk_filename = self.get_disk_filename(attach_id, filename)

      filesize = thedata.size()

      sql = "INSERT INTO attachments (id, container_id, container_type, filename, filesize, disk_filename, content_type, digest, downloads, author_id, created_on, description) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"

      self.red_exec_sql(sql, attach_id, bug_id, 'Issue', filename, filesize, disk_filename, mimetype, '', 0, submitter_id, creation_ts, description)

      File.open("#{ATTACHMENT_PATH}/#{disk_filename}", "wb") do |f|

        f.write(thedata)

      end

    end

  end

  def get_disk_filename(attach_id, filename)

    return "a#{attach_id}.#{self.get_file_extension(filename)}".downcase

  end

  def get_file_extension(s)

    m = /\.(\w+)$/.match(s)

    if(m)

      return m[1]

    else

      return 'dat'

    end

  end

  def migrate_members

    self.log("*** migrate members ***")

    self.bz_select_sql("SELECT DISTINCT user_group_map.user_id, group_control_map.product_id AS project_id FROM group_control_map, user_group_map WHERE group_control_map.group_id = user_group_map.group_id") do |row|

      user_id = row[0]

      product_id = row[1]

      role_id = DEFAULT_ROLE_ID

      created_on = "2007-01-01 12:00:00"

      mail_notification = 0

      self.red_exec_sql("INSERT INTO members (user_id, project_id, created_on, mail_notification) VALUES (?,?,?,?)", user_id, product_id, created_on, mail_notification)

    end

  end

  def migrate_member_roles

    self.log("*** migrate member roles ***")

    self.bz_select_sql("SELECT DISTINCT groups.name, group_control_map.product_id AS project_id FROM group_control_map, groups WHERE groups.id = group_control_map.group_id") do |row|

      group_name = row[0]

      product_id = row[1]

      role_id = DEFAULT_ROLE_ID

      created_on = "2007-01-01 12:00:00"

      mail_notification = 0

      self.red_exec_sql("INSERT INTO members (user_id, project_id, created_on, mail_notification) select (select id from users where lastname = ?),?,?,?", group_name, product_id, created_on, mail_notification)

          self.red_exec_sql("INSERT INTO member_roles (member_id, role_id, inherited_from) select (select members.id from members, users where members.user_id = users.id and users.lastname = ?),?,?", group_name, role_id, 0)

          self.red_exec_sql("INSERT INTO member_roles (member_id, role_id, inherited_from) select members.id, ?, (select members.id from members, users where members.user_id = users.id and users.lastname = ?) FROM members,users where members.project_id = ? and members.user_id = users.id and users.type = ?", role_id, group_name, product_id, 'User')

    end

  end

  def migrate_groups_users

    self.log("*** migrate groups users ***")

    self.red_select_sql("select (select members.user_id from members where members.id = mr.inherited_from) as group_id, m.user_id FROM member_roles as mr, members as m where mr.inherited_from is not null and mr.inherited_from <> 0 and mr.member_id = m.id") do |row|

      group_id = row[0]

      user_id = row[1]

      self.red_exec_sql("INSERT INTO groups_users (group_id, user_id) values (?, ?)", group_id, user_id)

    end

  end

  def insert_project_trackers(project_id)

    [1,2,3].each do |tracker_id|

      self.red_exec_sql("INSERT INTO projects_trackers (project_id, tracker_id) VALUES (?, ?)", project_id, tracker_id)

    end

  end

  def insert_project_modules(project_id)

    ['issue_tracking',

      'time_tracking',

      'news',

      'documents',

      'files',

      'wiki',

      'repository',

      'boards',].each do |m|

      self.red_exec_sql("INSERT INTO enabled_modules (project_id, name) VALUES (?, ?)", project_id, m)

    end

  end

  def bz_exec_sql(sql)

    self.log("bugzilla: #{sql}")

  end

  def bz_select_sql(sql, *args, &block)

    self.log("bugzilla: #{sql} args=#{args.join(',')}")

    statement = @bugzilladb.prepare(sql)

    statement.execute(*args)

    while row = statement.fetch do

      yield row

    end

    statement.close()

  end

  def red_exec_sql(sql, *args)

    self.log("redmine: #{sql} args=#{args.join(',')}")

    statement = @redminedb.prepare(sql)

    statement.execute(*args)

    statement.close()

  end

  def red_select_sql(sql, *args, &block)

    self.log("redmine: #{sql} args=#{args.join(',')}")

    statement = @redminedb.prepare(sql)

    statement.execute(*args)

    while row = statement.fetch do

      yield row

    end

    statement.close()

  end

end

begin

  bzred = BugzillaToRedmine.new

  bzred.migrate

rescue => e

  puts e.inspect

  puts e.backtrace

end