Redmine

require 'rexml/document'

require 'active_record'

require 'yaml'

require 'config/environment'

module JiraMigration

  include REXML

  file = File.new('backup_jira.xml')

  doc = Document.new file

  $doc = doc

  CONF_FILE = "map_jira_to_redmine.yml"

  $MIGRATED_USERS_BY_NAME = {} # Maps the Jira username to the Redmine Rails User object

  $MIGRATED_ISSUE_TYPES = {} 

  $MIGRATED_ISSUE_STATUS = {}

  $MIGRATED_ISSUE_PRIORITIES = {}

  $MIGRATED_ISSUE_TYPES_BY_ID = {} 

  $MIGRATED_ISSUE_STATUS_BY_ID = {}

  $MIGRATED_ISSUE_PRIORITIES_BY_ID = {}

  def self.get_all_options()

    # return all options 

    # Issue Type, Issue Status, Issue Priority

    ret = {}

    ret["types"] = self.get_jira_issue_types()

    ret["status"] = self.get_jira_status()

    ret["priorities"] = self.get_jira_priorities()

    return ret

  end

  def self.get_list_from_tag(xpath_query)

    # Get a tag node and get all attributes as a hash

    ret = []

    $doc.elements.each(xpath_query) {|node| ret.push(node.attributes.rehash)}

    return ret

  end

  class BaseJira

    attr_reader :tag

    attr_accessor :new_record

    MAP = {}

    def map

      self.class::MAP

    end

    def initialize(node)

      @tag = node

    end

    def method_missing(key, *args)

      if key.to_s.start_with?("jira_")

        attr = key.to_s.sub("jira_", "")

        return @tag.attributes[attr]

      end

      puts "Method missing: #{key}"

      raise NoMethodError key

    end

    def run_all_redmine_fields

      ret = {}

      self.methods.each do |method_name|

        m = method_name.to_s

        if m.start_with?("red_")

          mm = m.to_s.sub("red_", "")

          ret[mm] = self.send(m)

        end

      end

      return ret

    end

    def migrate

      all_fields = self.run_all_redmine_fields()

      pp("Saving:", all_fields)

      record = self.retrieve

      if record

        record.update_attributes(all_fields)

      else

        record = self.class::DEST_MODEL.new all_fields

      end

      if self.respond_to?("before_save")

        self.before_save(record)

      end

      record.save!

      record.reload

      self.map[self.jira_id] = record

      self.new_record = record

      if self.respond_to?("post_migrate")

        self.post_migrate(record)

      end

      return record 

    end

    def retrieve

      self.class::DEST_MODEL.find_by_name(self.jira_id)

    end

  end

  class JiraProject < BaseJira

    DEST_MODEL = Project

    MAP = {}

    def retrieve

      self.class::DEST_MODEL.find_by_identifier(self.red_identifier)

    end

    def post_migrate(new_record)

      if !new_record.module_enabled?('issue_tracking')

        new_record.enabled_modules << EnabledModule.new(:name => 'issue_tracking')

      end

      $MIGRATED_ISSUE_TYPES.values.uniq.each do |issue_type|

        if !new_record.trackers.include?(issue_type)

          new_record.trackers << issue_type

        end

      end

    end

    # here is the tranformation of Jira attributes in Redmine attribues

    def red_name

      self.jira_name

    end

    def red_description

      self.jira_name

    end

    def red_identifier

      ret = self.jira_key.downcase

      return ret

    end

  end

  class JiraUser < BaseJira

    DEST_MODEL = User

    MAP = {}

    #attr_reader :jira_fullname, :jira_email

    #def initialize(node)

    #  super

    #  # parsing specific things of each user

    #  @jira_fullname = get_property("fullName")

    #  @jira_email = get_property("email")

    #end

    def retrieve

      user = self.class::DEST_MODEL.find_by_login(self.red_login)

      if !user

        user = self.class::DEST_MODEL.find_by_mail(self.jira_email)

      end

      return user

    end

    def jira_fullname 

      get_property("fullName")

    end

    def jira_email

      get_property("email")

    end

    def get_property(property)

      # User properties (like fullname and email)

      # Wow... we need to find 2 things to reach the desired property

      entityId = self.jira_id

      query = "/entity-engine-xml/OSPropertyEntry[@entityId='#{entityId}' and @propertyKey='#{property}']/@id"

      prop = $doc.elements.each(query).first()

      prop = prop.value

      query = "/entity-engine-xml/OSPropertyString[@id='#{prop}']/@value"

      prop = $doc.elements.each(query).first()

      return prop.value

    end

    def get_first_name()

       firstname, lastname = self.jira_fullname.split ' ', 2 

       return firstname

    end

    def get_last_name()

       firstname, lastname = self.jira_fullname.split ' ', 2 

       return lastname

    end

    def migrate

      super

      $MIGRATED_USERS_BY_NAME[self.jira_name] = self.new_record

    end

    # First Name, Last Name, E-mail, Password

    # here is the tranformation of Jira attributes in Redmine attribues

    def red_firstname()

      self.get_first_name

    end

    def red_lastname

      self.get_last_name.sub("(", "").sub(")", "")

    end

    def red_mail

      self.jira_email

    end

    def red_password

      self.jira_name

    end

    def red_login

      self.jira_name

    end

    def before_save(new_record)

      new_record.login = red_login

    end

    #def red_username

    #  self.jira_name

    #end

  end

  class JiraComment < BaseJira

    DEST_MODEL = Journal

    MAP = {}

    def initialize(node)

      super

      # get a body from a comment

      # comment can have the comment body as a attribute or as a child tag

      @jira_body = @tag.attributes["body"] || @tag.elements["body"].text

    end

    def jira_marker

      return "FROM JIRA: #{self.jira_id}\n"

    end

    def retrieve

      Journal.first(:conditions => "notes LIKE '#{self.jira_marker}%'")

    end

    # here is the tranformation of Jira attributes in Redmine attribues

    def red_notes

      self.jira_marker + "\n" + @jira_body

    end

    def red_created_on

      DateTime.parse(self.jira_created)

    end

    def red_user

      # retrieving the Rails object

      $MIGRATED_USERS_BY_NAME[self.jira_author]

    end

    def red_journalized

      # retrieving the Rails object

      JiraIssue::MAP[self.jira_issue]

    end

  end

  class JiraIssue < BaseJira

    DEST_MODEL = Issue

    MAP = {}

    #attr_reader :jira_id, :jira_key, :jira_project, :jira_reporter, 

    #            :jira_type, :jira_summary, :jira_assignee, :jira_priority

    #            :jira_resolution, :jira_status, :jira_created, :jira_resolutiondate

    attr_reader  :jira_description

    def initialize(node_tag)

      super

      @jira_description = @tag.elements["description"].text if @tag.elements["description"]

    end

    def jira_marker

      return "FROM JIRA: #{self.jira_key}\n"

    end

    def retrieve

      Issue.first(:conditions => "description LIKE '#{self.jira_marker}%'")

    end

    def red_project

      # needs to return the Rails Project object

      proj = self.jira_project

      JiraProject::MAP[proj]

    end

    def red_subject

      #:subject => encode(issue.title[0, limit_for(Issue, 'subject')]),

      self.jira_summary

    end

    def red_description

      dsc = self.jira_marker + "\n"

      if @jira_description

        dsc += @jira_description 

      else

        dsc += self.red_subject

      end

      return dsc

    end

    def red_priority

      name = $MIGRATED_ISSUE_PRIORITIES_BY_ID[self.jira_priority]

      return $MIGRATED_ISSUE_PRIORITIES[name]

    end

    def red_created_on

      Time.parse(self.jira_created)

    end

    def red_updated_on

      Time.parse(self.jira_updated)

    end

    def red_status

      name = $MIGRATED_ISSUE_STATUS_BY_ID[self.jira_status]

      return $MIGRATED_ISSUE_STATUS[name]

    end

    def red_tracker

      type_name = $MIGRATED_ISSUE_TYPES_BY_ID[self.jira_type]

      return $MIGRATED_ISSUE_TYPES[type_name]

    end

    def red_author

      $MIGRATED_USERS_BY_NAME[self.jira_reporter]

    end

    def red_assigned_to

      $MIGRATED_USERS_BY_NAME[self.jira_assignee]

    end

  end

  class JiraAttachment < BaseJira

    DEST_MODEL = Attachment

    MAP = {}

    def retrieve

      self.class::DEST_MODEL.find_by_disk_filename(self.red_filename)

    end

    def before_save(new_record)

      new_record.container = self.red_container

      pp(new_record)

    end

    # here is the tranformation of Jira attributes in Redmine attribues

    #<FileAttachment id="10084" issue="10255" mimetype="image/jpeg" filename="Landing_Template.jpg" 

    #                created="2011-05-05 15:54:59.411" filesize="236515" author="emiliano"/>

    def red_filename

      self.jira_filename.gsub(/[^\w\.\-]/,'_')  # stole from Redmine: app/model/attachment (methods sanitize_filenanme)

    end

    def red_disk_filename 

      Attachment.disk_filename(self.jira_filename)

    end

    def red_content_type 

      self.jira_mimetype.to_s.chomp

    end

    def red_filesize 

      self.jira_filesize

    end

    def red_created_on

      DateTime.parse(self.jira_created)

    end

    def red_author

      $MIGRATED_USERS_BY_NAME[self.jira_author]

    end

    def red_container

      JiraIssue::MAP[self.jira_issue]

    end

  end

  def self.parse_projects()

    # PROJECTS:

    # for project we need (identifies, name and description)

    # in exported data we have name and key, in Redmine name and descr. will be equal

    # the key will be the identifier

    projs = []

    $doc.elements.each('/*/Project') do |node|

      proj = JiraProject.new(node)

      projs.push(proj)

    end

    migrated_projects = {}

    projs.each do |p|

      #puts "Name and descr.: #{p.red_name} and #{p.red_description}"

      #puts "identifier: #{p.red_identifier}"

      migrated_projects[p.jira_id] = p

    end

    #puts migrated_projects

    return projs

  end

  def self.parse_users()

    users = []

    #users = self.get_list_from_tag('/*/OSUser')

    # For users in Redmine we need:

    # First Name, Last Name, E-mail, Password

    # In Jira, the fullname and email are property (a little more hard to get)

    $doc.elements.each('/entity-engine-xml/OSUser') do |node|

      user = JiraUser.new(node)

      users.push(user)

    end

    return users

  end

  ISSUE_TYPE_MARKER = "(choose a Redmine Tracker)"

  DEFAULT_ISSUE_TYPE_MAP = {

    # Default map from Jira (key) to Redmine (value)

    # the comments on right side are Jira definitions - http://confluence.atlassian.com/display/JIRA/What+is+an+Issue#

    "Bug" => "Bug",              # A problem which impairs or prevents the functions of the product.

    "Improvement" => "Feature",  # An enhancement to an existing feature.

    "New Feature" => "Feature",  # A new feature of the product.

    "Task" => "Task",            # A task that needs to be done.

    "Custom Issue" => "Support", # A custom issue type, as defined by your organisation if required.

  }

  def self.get_jira_issue_types()

    # Issue Type

    issue_types = self.get_list_from_tag('/*/IssueType') 

    #migrated_issue_types = {"jira_type" => "redmine tracker"}

    migrated_issue_types = {}

    issue_types.each do |issue|

      migrated_issue_types[issue["name"]] = DEFAULT_ISSUE_TYPE_MAP.fetch(issue["name"], ISSUE_TYPE_MARKER)

      $MIGRATED_ISSUE_TYPES_BY_ID[issue["id"]] = issue["name"]

    end

    return migrated_issue_types

  end

  ISSUE_STATUS_MARKER = "(choose a Redmine Issue Status)"

  DEFAULT_ISSUE_STATUS_MAP = {

    # Default map from Jira (key) to Redmine (value)

    # the comments on right side are Jira definitions - http://confluence.atlassian.com/display/JIRA/What+is+an+Issue#

    "Open" => "New",                # This issue is in the initial 'Open' state, ready for the assignee to start work on it.

    "In Progress" => "In Progress", # This issue is being actively worked on at the moment by the assignee.

    "Resolved" => "Resolved",       # A Resolution has been identified or implemented, and this issue is awaiting verification by the reporter. From here, issues are either 'Reopened' or are 'Closed'.

    "Reopened" => "Assigned",       # This issue was once 'Resolved' or 'Closed', but is now being re-examined. (For example, an issue with a Resolution of 'Cannot Reproduce' is Reopened when more information becomes available and the issue becomes reproducible). From here, issues are either marked In Progress, Resolved or Closed.

    "Closed" => "Closed",           # This issue is complete. ## Be careful to choose one which a "issue closed" attribute marked :-)

  }

  def self.get_jira_status()

    # Issue Status

    issue_status = self.get_list_from_tag('/*/Status') 

    migrated_issue_status = {}

    issue_status.each do |issue|

      migrated_issue_status[issue["name"]] = DEFAULT_ISSUE_STATUS_MAP.fetch(issue["name"], ISSUE_STATUS_MARKER)

      $MIGRATED_ISSUE_STATUS_BY_ID[issue["id"]] = issue["name"]

    end

    return migrated_issue_status

  end

  ISSUE_PRIORITY_MARKER = "(choose a Redmine Enumeration Issue Priority)"

  DEFAULT_ISSUE_PRIORITY_MAP = {

    # Default map from Jira (key) to Redmine (value)

    # the comments on right side are Jira definitions - http://confluence.atlassian.com/display/JIRA/What+is+an+Issue#

     "Blocker" => "Immediate", # Highest priority. Indicates that this issue takes precedence over all others.

     "Critical" => "Urgent",   # Indicates that this issue is causing a problem and requires urgent attention.

     "Major" => "High",        # Indicates that this issue has a significant impact.

     "Minor" => "Normal",      # Indicates that this issue has a relatively minor impact.

     "Trivial" => "Low",       # Lowest priority.

  }

  def self.get_jira_priorities()

    # Issue Priority

    issue_priority = self.get_list_from_tag('/*/Priority') 

    migrated_issue_priority = {}

    issue_priority.each do |issue|

      migrated_issue_priority[issue["name"]] = DEFAULT_ISSUE_PRIORITY_MAP.fetch(issue["name"], ISSUE_PRIORITY_MARKER)

      $MIGRATED_ISSUE_PRIORITIES_BY_ID[issue["id"]] = issue["name"]

    end

    return migrated_issue_priority

  end

  def self.parse_comments()

    ret = []

    $doc.elements.each('/*/Action[@type="comment"]') do |node|

      comment = JiraComment.new(node)

      ret.push(comment)

    end

    return ret

  end 

  def self.parse_issues()

    ret = []

    $doc.elements.each('/*/Issue') do |node|

      issue = JiraIssue.new(node)

      ret.push(issue)

    end

    return ret

  end 

  def self.parse_attachments()

    attachs = []

    $doc.elements.each('/*/FileAttachment') do |node|

      attach = JiraAttachment.new(node)

      attachs.push(attach)

    end

    return attachs

  end

end

namespace :jira_migration do

  desc "Generates the configuration for the map things from Jira to Redmine"

  task :generate_conf => :environment do

    conf_file = JiraMigration::CONF_FILE

    conf_exists = File.exists?(conf_file)

    if conf_exists

      puts "You already have a conf file"

      print "You want overwrite it ? [y/N] "

      overwrite = STDIN.gets.match(/^y$/i)

    end

    if !conf_exists or overwrite

      # Let's give the user all options to fill out

      options = JiraMigration.get_all_options()

      File.open(conf_file, "w"){ |f| f.write(options.to_yaml) }

      puts "This migration script needs the migration table to continue "

      puts "Please... fill the map table on the file: '#{conf_file}' and run again the script"

      puts "To start the options again, just remove the file '#{conf_file} and run again the script"

      exit(0)

    end

  end

  desc "Gets the configuration from YAML"

  task :pre_conf => :environment do

    conf_file = JiraMigration::CONF_FILE

    conf_exists = File.exists?(conf_file)

    if !conf_exists 

      Rake::Task['jira_migration:generate_conf'].invoke

    end

    $confs = YAML.load_file(conf_file)

  end

  desc "Tests all parsers!"

  task :test_all_migrations => [:environment, :pre_conf,

                              :test_parse_projects, 

                              :test_parse_users, 

                              :test_parse_comments, 

                              :test_parse_issues, 

                             ] do

    puts "All parsers was run! :-)"

  end

  desc "Tests all parsers!"

  task :do_all_migrations => [:environment, :pre_conf,

                              :migrate_issue_types, 

                              :migrate_issue_status, 

                              :migrate_issue_priorities, 

                              :migrate_projects, 

                              :migrate_users, 

                              :migrate_issues, 

                              :migrate_comments, 

                              :migrate_attachments,

                             ] do

    puts "All migrations done! :-)"

  end

  desc "Migrates Jira Issue Types to Redmine Trackes"

  task :migrate_issue_types => [:environment, :pre_conf] do

    JiraMigration.get_jira_issue_types()

    types = $confs["types"]

    types.each do |key, value|

      t = Tracker.find_or_create_by_name(value)

      t.save!

      t.reload

      $MIGRATED_ISSUE_TYPES[key] = t

    end

    puts "Migrated issue types"

  end

  desc "Migrates Jira Issue Status to Redmine Status"

  task :migrate_issue_status => [:environment, :pre_conf] do

    JiraMigration.get_jira_status()

    status = $confs["status"]

    status.each do |key, value|

      s = IssueStatus.find_or_create_by_name(value)

      s.save!

      s.reload

      $MIGRATED_ISSUE_STATUS[key] = s

    end

    puts "Migrated issue status"

  end

  desc "Migrates Jira Issue Priorities to Redmine Priorities"

  task :migrate_issue_priorities => [:environment, :pre_conf] do

    JiraMigration.get_jira_priorities()

    priorities = $confs["priorities"]

    priorities.each do |key, value|

      p = IssuePriority.find_or_create_by_name(value)

      p.save!

      p.reload

      $MIGRATED_ISSUE_PRIORITIES[key] = p

    end

    puts "Migrated issue priorities"

  end

  desc "Migrates Jira Projects to Redmine Projects"

  task :migrate_projects => :environment do

    projects = JiraMigration.parse_projects()

    projects.each do |p|

      #pp(p)

      p.migrate

    end

  end

  desc "Migrates Jira Users to Redmine Users"

  task :migrate_users => :environment do

    users = JiraMigration.parse_users()

    users.each do |u|

      #pp(u)

      u.migrate

    end

  end

  desc "Migrates Jira Issues to Redmine Issues"

  task :migrate_issues => :environment do

    issues = JiraMigration.parse_issues()

    issues.each do |i|

      #pp(i)

      i.migrate

    end

  end

  desc "Migrates Jira Issues Comments to Redmine Issues Journals (Notes)"

  task :migrate_comments => :environment do

    comments = JiraMigration.parse_comments()

    comments.each do |c|

      #pp(c)

      c.migrate

    end

  end

  desc "Migrates Jira Issues Attachments to Redmine Attachments"

  task :migrate_attachments => :environment do

    attachs = JiraMigration.parse_attachments()

    attachs.each do |a|

      #pp(c)

      a.migrate

    end

  end

  # Tests.....

  desc "Just pretty print Jira Projects on screen"

  task :test_parse_projects => :environment do

    projects = JiraMigration.parse_projects()

    projects.each {|p| pp(p.run_all_redmine_fields) }

  end

  desc "Just pretty print Jira Users on screen"

  task :test_parse_users => :environment do

    users = JiraMigration.parse_users()

    users.each {|u| pp( u.run_all_redmine_fields) }

  end

  desc "Just pretty print Jira Comments on screen"

  task :test_parse_comments => :environment do

    comments = JiraMigration.parse_comments()

    comments.each {|c| pp( c.run_all_redmine_fields) }

  end

  desc "Just pretty print Jira Issues on screen"

  task :test_parse_issues => :environment do

    issues = JiraMigration.parse_issues()

    issues.each {|i| pp( i.run_all_redmine_fields) }

  end

end