Redmine

      DEFAULT_PRIORITY = priorities[1]

      PRIORITY_MAPPING = {10 => priorities[0], # none

                          20 => priorities[0], # low

                          30 => priorities[1], # normal

                          40 => priorities[2], # high

                          50 => priorities[3], # urgent

                          60 => priorities[4]  # immediate

        read_attribute(:name).slice(0, Project::IDENTIFIER_MAX_LENGTH).downcase.gsub(/[^a-z0-9\-]+/, '-')

    class MantisProjectHierarchy < ActiveRecord::Base

        self.table_name = :mantis_project_hierarchy_table

    end    

      self.table_name = :mantis_category_table

      def category

        read_attribute(:name).slice(0,30)

      end

      belongs_to :category, :class_name => "MantisCategory", :foreign_key => :category_id

      self.inheritance_column = :none

                     :last_login_on => (user.last_visit ? Time.at(user.last_visit).to_date : nil)

      versions_locked = []

      inheritable_categories = false

        inheritable_categories = p.has_attribute?("inherit_categs") unless inheritable_categories

        p.is_public = (project.view_state == 10)

        p.enabled_module_names = ['issue_tracking', 'news', 'wiki', 'calendar', 'gantt', 'time_tracking']

                          :effective_date => (version.date_order ? Time.at(version.date_order).to_date : nil)

          # we cannot directly lock versions, cause otherwise some bugs will not be migrated, that why we remember the versions to be locked after issues migration

          if version.obsolete == 1

            versions_locked << v

          end

          g = IssueCategory.new :name => category.category

      # Project Hierarchy

      print "Making Project Hierarchy"

      MantisProjectHierarchy.find(:all).each do |link|

        next unless p = Project.find_by_id(projects_map[link.child_id])

        p.set_parent!(projects_map[link.parent_id])

        if link.inherit_parent == 1

          if inheritable_categories # p.has_attribute?("inherit_categs")

            p.inherit_categs = 1

          end

          # Turn on the users inheritance

          p.inherit_members = 1

          p.save

          # Turn on the versions inheritance

          parent_project = Project.find_by_id(projects_map[link.parent_id])

          parent_project.versions.each do |version|

            version.sharing = 'descendants'

            version.save

          end

        end

        print '.'

      end

      puts

      ActiveRecord::Base.record_timestamps = false

                      :created_on => (bug.date_submitted ? Time.at(bug.date_submitted).to_date : nil),

                      :updated_on => (bug.last_updated ? Time.at(bug.last_updated).to_date : nil)

        i.category = IssueCategory.find_by_project_id_and_name(i.project_id, bug.category.category) unless bug.category.blank?

        if (i.category.nil?) && inheritable_categories

          p = Project.find_by_id(projects_map[bug.project_id])

          i.category = p.inherited_categories.find{|c| c.name == bug.category.category}

        end

        if !(bug.fixed_in_version.blank? && bug.target_version.blank?)

          p = Project.find_by_id(projects_map[bug.project_id])

          if !bug.fixed_in_version.blank?

            vv = bug.fixed_in_version

          else

            vv = bug.target_version

          end

          i.fixed_version = p.shared_versions.find{|v| v.name == vv}

        end

        i.start_date = Time.at(bug.date_submitted).to_date

        if bug.due_date > bug.date_submitted

          i.due_date = Time.at(bug.due_date).to_date

        elsif bug.status >= 80 && i.updated_on > i.start_date

          i.due_date = i.updated_on

        end

                          :created_on => Time.at(note.date_submitted).to_date

          a = Attachment.new :created_on => (file.date_added ? Time.at(file.date_added).to_date : nil)

      # Locking versions after all bugs where migrated, otherwise no bugs with the locked version as target will be migrated

      versions_locked.each do |version|

        version.status = 'locked'

        version.save

      end

      #debugger

      ActiveRecord::Base.record_timestamps = true

                     :created_on => Time.at(news.date_posted).to_date