jro_apps/redmine Commit - r15108:e3875ffd5739

Make Tracker map-able for CSV import (#22951)....

Jean-Philippe Lang -

r15108:e3875ffd5739

parent child

Context file:

r15108:e3875ffd5739

Collapse all files

app/controllers/imports_controller.rb +1 -5

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 'csv'
             class ImportsController < ApplicationController
               before_filter :find_import, :only => [:show, :settings, :mapping, :run]
               before_filter :authorize_global
               helper :issues
               def new
               end
               def create
                 @import = IssueImport.new
                 @import.user = User.current
                 @import.file = params[:file]
                 @import.set_default_settings
                 if @import.save
                   redirect_to import_settings_path(@import)
                 else
                   render :action => 'new'
                 end
               end
               def show
               end
               def settings
                 if request.post? && @import.parse_file
                   redirect_to import_mapping_path(@import)
                 end
               rescue CSV::MalformedCSVError => e
                 flash.now[:error] = l(:error_invalid_csv_file_or_settings)
               rescue ArgumentError, Encoding::InvalidByteSequenceError => e
                 flash.now[:error] = l(:error_invalid_file_encoding, :encoding => ERB::Util.h(@import.settings['encoding']))
               rescue SystemCallError => e
                 flash.now[:error] = l(:error_can_not_read_import_file)
               end
               def mapping
-                issue = Issue.new
+                @custom_fields = @import.mappable_custom_fields
-                issue.project = @import.project
-                issue.tracker = @import.tracker
-                @attributes = issue.safe_attribute_names
-                @custom_fields = issue.editable_custom_field_values.map(&:custom_field)
                 if request.post?
                   respond_to do |format|
                     format.html {
                       if params[:previous]
                         redirect_to import_settings_path(@import)
                       else
                         redirect_to import_run_path(@import)
                       end
                     }
                     format.js # updates mapping form on project or tracker change
                   end
                 end
               end
               def run
                 if request.post?
                   @current = @import.run(
                     :max_items => max_items_per_request,
                     :max_time => 10.seconds
                   )
                   respond_to do |format|
                     format.html {
                       if @import.finished?
                         redirect_to import_path(@import)
                       else
                         redirect_to import_run_path(@import)
                       end
                     }
                     format.js
                   end
                 end
               end
               private
               def find_import
                 @import = Import.where(:user_id => User.current.id, :filename => params[:id]).first
                 if @import.nil?
                   render_404
                   return
                 elsif @import.finished? && action_name != 'show'
                   redirect_to import_path(@import)
                   return
                 end
                 update_from_params if request.post?
               end
               def update_from_params
                 if params[:import_settings].is_a?(Hash)
                   @import.settings ||= {}
                   @import.settings.merge!(params[:import_settings])
                   @import.save!
                 end
               end
               def max_items_per_request
               end
             end

app/helpers/imports_helper.rb +5 -1

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2016  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.
             module ImportsHelper
               def options_for_mapping_select(import, field, options={})
                 tags = "".html_safe
                 blank_text = options[:required] ? "-- #{l(:actionview_instancetag_blank_option)} --" : "&nbsp;".html_safe
                 tags << content_tag('option', blank_text, :value => '')
                 tags << options_for_select(import.columns_options, import.mapping[field])
+                if values = options[:values]
+                  tags << content_tag('option', '--', :disabled => true)
+                  tags << options_for_select(values.map {|text, value| [text, "value:#{value}"]}, import.mapping[field])
+                end
                 tags
               end
               def mapping_select_tag(import, field, options={})
                 name = "import_settings[mapping][#{field}]"
-                select_tag name, options_for_mapping_select(import, field, options)
+                select_tag name, options_for_mapping_select(import, field, options), :id => "import_mapping_#{field}"
               end
               # Returns the options for the date_format setting
               def date_format_options
                 Import::DATE_FORMATS.map do |f|
                   format = f.gsub('%', '').gsub(/[dmY]/) do
                     {'d' => 'DD', 'm' => 'MM', 'Y' => 'YYYY'}[$&]
                   end
                   [format, f]
                 end
               end
             end

app/models/issue_import.rb +31 -3

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 IssueImport < Import
               # Returns the objects that were imported
               def saved_objects
                 object_ids = saved_items.pluck(:obj_id)
                 objects = Issue.where(:id => object_ids).order(:id).preload(:tracker, :priority, :status)
               end
               # Returns a scope of projects that user is allowed to
               # import issue to
               def allowed_target_projects
                 Project.allowed_to(user, :import_issues)
               end
               def project
                 project_id = mapping['project_id'].to_i
                 allowed_target_projects.find_by_id(project_id) || allowed_target_projects.first
               end
               # Returns a scope of trackers that user is allowed to
               # import issue to
               def allowed_target_trackers
                 Issue.allowed_target_trackers(project, user)
               end
               def tracker
-                tracker_id = mapping['tracker_id'].to_i
+                if mapping['tracker'].to_s =~ /\Avalue:(\d+)\z/
-                allowed_target_trackers.find_by_id(tracker_id) || allowed_target_trackers.first
+                  tracker_id = $1.to_i
+                  allowed_target_trackers.find_by_id(tracker_id)
+                end
               end
               # Returns true if missing categories should be created during the import
               def create_categories?
                 user.allowed_to?(:manage_categories, project) &&
                   mapping['create_categories'] == '1'
               end
               # Returns true if missing versions should be created during the import
               def create_versions?
                 user.allowed_to?(:manage_versions, project) &&
                   mapping['create_versions'] == '1'
               end
+              def mappable_custom_fields
+                if tracker
+                  issue = Issue.new
+                  issue.project = project
+                  issue.tracker = tracker
+                  issue.editable_custom_field_values(user).map(&:custom_field)
+                elsif project
+                  project.all_issue_custom_fields
+                else
+                  []
+                end
+              end
               private
               def build_object(row)
                 issue = Issue.new
                 issue.author = user
                 issue.notify = false
+                tracker_id = nil
+                if tracker
+                  tracker_id = tracker.id
+                elsif tracker_name = row_value(row, 'tracker')
+                  tracker_id = allowed_target_trackers.named(tracker_name).first.try(:id)
+                end
                 attributes = {
                   'project_id' => mapping['project_id'],
-                  'tracker_id' => mapping['tracker_id'],
+                  'tracker_id' => tracker_id,
                   'subject' => row_value(row, 'subject'),
                   'description' => row_value(row, 'description')
                 }
+                attributes
                 issue.send :safe_attributes=, attributes, user
                 attributes = {}
                 if priority_name = row_value(row, 'priority')
                   if priority_id = IssuePriority.active.named(priority_name).first.try(:id)
                     attributes['priority_id'] = priority_id
                   end
                 end
                 if issue.project && category_name = row_value(row, 'category')
                   if category = issue.project.issue_categories.named(category_name).first
                     attributes['category_id'] = category.id
                   elsif create_categories?
                     category = issue.project.issue_categories.build
                     category.name = category_name
                     if category.save
                       attributes['category_id'] = category.id
                     end
                   end
                 end
                 if assignee_name = row_value(row, 'assigned_to')
                   if assignee = Principal.detect_by_keyword(issue.assignable_users, assignee_name)
                     attributes['assigned_to_id'] = assignee.id
                   end
                 end
                 if issue.project && version_name = row_value(row, 'fixed_version')
                   if version = issue.project.versions.named(version_name).first
                     attributes['fixed_version_id'] = version.id
                   elsif create_versions?
                     version = issue.project.versions.build
                     version.name = version_name
                     if version.save
                       attributes['fixed_version_id'] = version.id
                     end
                   end
                 end
                 if is_private = row_value(row, 'is_private')
                   if yes?(is_private)
                     attributes['is_private'] = '1'
                   end
                 end
                 if parent_issue_id = row_value(row, 'parent_issue_id')
                   if parent_issue_id =~ /\A(#)?(\d+)\z/
                     parent_issue_id = $2
                     if $1
                       attributes['parent_issue_id'] = parent_issue_id
                     elsif issue_id = items.where(:position => parent_issue_id).first.try(:obj_id)
                       attributes['parent_issue_id'] = issue_id
                     end
                   else
                     attributes['parent_issue_id'] = parent_issue_id
                   end
                 end
                 if start_date = row_date(row, 'start_date')
                   attributes['start_date'] = start_date
                 end
                 if due_date = row_date(row, 'due_date')
                   attributes['due_date'] = due_date
                 end
                 if estimated_hours = row_value(row, 'estimated_hours')
                   attributes['estimated_hours'] = estimated_hours
                 end
                 if done_ratio = row_value(row, 'done_ratio')
                   attributes['done_ratio'] = done_ratio
                 end
                 attributes['custom_field_values'] = issue.custom_field_values.inject({}) do |h, v|
                   value = case v.custom_field.field_format
                   when 'date'
                     row_date(row, "cf_#{v.custom_field.id}")
                   else
                     row_value(row, "cf_#{v.custom_field.id}")
                   end
                   if value
                     h[v.custom_field.id.to_s] = v.custom_field.value_from_keyword(value, issue)
                   end
                   h
                 end
                 issue.send :safe_attributes=, attributes, user
+                if issue.tracker_id != tracker_id
+                  issue.tracker_id = nil
+                end
                 issue
               end
             end

app/views/imports/_fields_mapping.html.erb +6 -6

-            <div class="splitcontent">
-            <div class="splitcontentleft">
             <p>
               <label><%= l(:label_project) %></label>
               <%= select_tag 'import_settings[mapping][project_id]',
                     options_for_select(project_tree_options_for_select(@import.allowed_target_projects, :selected => @import.project)),
-                    :id => 'issue_project_id' %>
+                    :id => 'import_mapping_project_id' %>
             </p>
             <p>
               <label><%= l(:label_tracker) %></label>
-              <%= select_tag 'import_settings[mapping][tracker_id]',
+              <%= mapping_select_tag @import, 'tracker', :required => true,
-                    options_for_select(@import.allowed_target_trackers.sorted.map {|t| [t.name, t.id]}, @import.tracker.try(:id)),
+                    :values => @import.allowed_target_trackers.sorted.map {|t| [t.name, t.id]} %>
-                    :id => 'issue_tracker_id' %>
             </p>
+            <div class="splitcontent">
+            <div class="splitcontentleft">
             <p>
               <label><%= l(:field_subject) %></label>
               <%= mapping_select_tag @import, 'subject', :required => true %>
             </p>
             <p>
               <label><%= l(:field_description) %></label>
               <%= mapping_select_tag @import, 'description' %>
             </p>
             <p>
               <label><%= l(:field_priority) %></label>
               <%= mapping_select_tag @import, 'priority' %>
             </p>
             <p>
               <label><%= l(:field_category) %></label>
               <%= mapping_select_tag @import, 'category' %>
               <% if User.current.allowed_to?(:manage_categories, @import.project) %>
                 <label class="block">
                   <%= check_box_tag 'import_settings[mapping][create_categories]', '1', @import.create_categories? %>
                   <%= l(:label_create_missing_values) %>
                 </label>
               <% end %>
             </p>
             <p>
               <label><%= l(:field_assigned_to) %></label>
               <%= mapping_select_tag @import, 'assigned_to' %>
             </p>
             <p>
               <label><%= l(:field_fixed_version) %></label>
               <%= mapping_select_tag @import, 'fixed_version' %>
               <% if User.current.allowed_to?(:manage_versions, @import.project) %>
                 <label class="block">
                   <%= check_box_tag 'import_settings[mapping][create_versions]', '1', @import.create_versions? %>
                   <%= l(:label_create_missing_values) %>
                 </label>
               <% end %>
             </p>
             <% @custom_fields.each do |field| %>
               <p>
                 <label><%= field.name %></label>
                 <%= mapping_select_tag @import, "cf_#{field.id}" %>
               </p>
             <% end %>
             </div>
             <div class="splitcontentright">
             <p>
               <label><%= l(:field_is_private) %></label>
               <%= mapping_select_tag @import, 'is_private' %>
             </p>
             <p>
               <label><%= l(:field_parent_issue) %></label>
               <%= mapping_select_tag @import, 'parent_issue_id' %>
             </p>
             <p>
               <label><%= l(:field_start_date) %></label>
               <%= mapping_select_tag @import, 'start_date' %>
             </p>
             <p>
               <label><%= l(:field_due_date) %></label>
               <%= mapping_select_tag @import, 'due_date' %>
             </p>
             <p>
               <label><%= l(:field_estimated_hours) %></label>
               <%= mapping_select_tag @import, 'estimated_hours' %>
             </p>
             <p>
               <label><%= l(:field_done_ratio) %></label>
               <%= mapping_select_tag @import, 'done_ratio' %>
             </p>
             </div>
             </div>

app/views/imports/mapping.html.erb +1 -1

             <h2><%= l(:label_import_issues) %></h2>
             <%= form_tag(import_mapping_path(@import), :id => "import-form") do %>
               <fieldset class="box tabular">
                 <legend><%= l(:label_fields_mapping) %></legend>
                 <div id="fields-mapping">
                   <%= render :partial => 'fields_mapping' %>
                 </div>
               </fieldset>
               <div class="autoscroll">
               <fieldset class="box">
                 <legend><%= l(:label_file_content_preview) %></legend>
                   <table class="sample-data">
                   <% @import.first_rows.each do |row| %>
                     <tr>
                       <%= row.map {|c| content_tag 'td', truncate(c.to_s, :length => 50) }.join("").html_safe %>
                     </tr>
                   <% end %>
                   </table>
               </fieldset>
               </div>
               <p>
                 <%= button_tag("\xc2\xab " + l(:label_previous), :name => 'previous') %>
                 <%= submit_tag l(:button_import) %>
               </p>
             <% end %>
             <% content_for :sidebar do %>
                 <%= render :partial => 'issues/sidebar' %>
             <% end %>
             <%= javascript_tag do %>
             $(document).ready(function() {
-              $('#fields-mapping').on('change', '#issue_project_id, #issue_tracker_id', function(){
+              $('#fields-mapping').on('change', '#import_mapping_project_id, #import_mapping_tracker', function(){
                 $.ajax({
                   url: '<%= import_mapping_path(@import, :format => 'js') %>',
                   type: 'post',
                   data: $('#import-form').serialize()
                 });
               });
               $('#import-form').submit(function(){
                 $('#import-details').show().addClass('ajax-loading');
                 $('#import-progress').progressbar({value: 0, max: <%= @import.total_items || 0 %>});
               });
             });
             <% end %>

test/fixtures/files/import_issues.csv +4 -4

@@ -1,4 +1,4
1	priority;subject;description;start_date;due_date;parent;private;progress;custom;version;category;user;estimated_hours	1	priority;subject;description;start_date;due_date;parent;private;progress;custom;version;category;user;estimated_hours;tracker
2	High;First;First description;2015-07-08;2015-08-25;;no;;PostgreSQL;;New category;dlopper;1	2	High;First;First description;2015-07-08;2015-08-25;;no;;PostgreSQL;;New category;dlopper;1;bug
3	Normal;Child 1;Child description;;;1;yes;10;MySQL;2.0;New category;;2	3	Normal;Child 1;Child description;;;1;yes;10;MySQL;2.0;New category;;2;feature request
4	Normal;Child of existing issue;Child description;;;#2;no;20;;2.1;Printing;;3	4	Normal;Child of existing issue;Child description;;;#2;no;20;;2.1;Printing;;3;bug

test/object_helpers.rb +1 -1

             module ObjectHelpers
               def User.generate!(attributes={})
                 @generated_user_login ||= 'user0'
                 @generated_user_login.succ!
                 user = User.new(attributes)
                 user.login = @generated_user_login.dup if user.login.blank?
                 user.mail = "#{@generated_user_login}@example.com" if user.mail.blank?
                 user.firstname = "Bob" if user.firstname.blank?
                 user.lastname = "Doe" if user.lastname.blank?
                 yield user if block_given?
                 user.save!
                 user
               end
               def User.add_to_project(user, project, roles=nil)
                 roles = Role.find(1) if roles.nil?
                 roles = [roles] if roles.is_a?(Role)
                 Member.create!(:principal => user, :project => project, :roles => roles)
               end
               def Group.generate!(attributes={})
                 @generated_group_name ||= 'Group 0'
                 @generated_group_name.succ!
                 group = Group.new(attributes)
                 group.name = @generated_group_name.dup if group.name.blank?
                 yield group if block_given?
                 group.save!
                 group
               end
               def Project.generate!(attributes={})
                 @generated_project_identifier ||= 'project-0000'
                 @generated_project_identifier.succ!
                 project = Project.new(attributes)
                 project.name = @generated_project_identifier.dup if project.name.blank?
                 project.identifier = @generated_project_identifier.dup if project.identifier.blank?
                 yield project if block_given?
                 project.save!
                 project
               end
               def Project.generate_with_parent!(*args)
                 attributes = args.last.is_a?(Hash) ? args.pop : {}
                 parent = args.size > 0 ? args.first : Project.generate!
                 project = Project.generate!(attributes) do |p|
                   p.parent = parent
                 end
                 parent.reload if parent
                 project
               end
               def IssueStatus.generate!(attributes={})
                 @generated_status_name ||= 'Status 0'
                 @generated_status_name.succ!
                 status = IssueStatus.new(attributes)
                 status.name = @generated_status_name.dup if status.name.blank?
                 yield status if block_given?
                 status.save!
                 status
               end
               def Tracker.generate(attributes={})
                 @generated_tracker_name ||= 'Tracker 0'
                 @generated_tracker_name.succ!
                 tracker = Tracker.new(attributes)
                 tracker.name = @generated_tracker_name.dup if tracker.name.blank?
                 tracker.default_status ||= IssueStatus.order('position').first || IssueStatus.generate!
                 yield tracker if block_given?
                 tracker
               end
               def Tracker.generate!(attributes={}, &block)
                 tracker = Tracker.generate(attributes, &block)
                 tracker.save!
                 tracker
               end
               def Role.generate!(attributes={})
                 @generated_role_name ||= 'Role 0'
                 @generated_role_name.succ!
                 role = Role.new(attributes)
                 role.name = @generated_role_name.dup if role.name.blank?
                 yield role if block_given?
                 role.save!
                 role
               end
               # Generates an unsaved Issue
               def Issue.generate(attributes={})
                 issue = Issue.new(attributes)
                 issue.project ||= Project.find(1)
                 issue.tracker ||= issue.project.trackers.first
                 issue.subject = 'Generated' if issue.subject.blank?
                 issue.author ||= User.find(2)
                 yield issue if block_given?
                 issue
               end
               # Generates a saved Issue
               def Issue.generate!(attributes={}, &block)
                 issue = Issue.generate(attributes, &block)
                 issue.save!
                 issue
               end
               # Generates an issue with 2 children and a grandchild
               def Issue.generate_with_descendants!(attributes={})
                 issue = Issue.generate!(attributes)
                 child = Issue.generate!(:project => issue.project, :subject => 'Child1', :parent_issue_id => issue.id)
                 Issue.generate!(:project => issue.project, :subject => 'Child2', :parent_issue_id => issue.id)
                 Issue.generate!(:project => issue.project, :subject => 'Child11', :parent_issue_id => child.id)
                 issue.reload
               end
               def Issue.generate_with_child!(attributes={})
                 issue = Issue.generate!(attributes)
                 Issue.generate!(:parent_issue_id => issue.id)
                 issue.reload
               end
               def Journal.generate!(attributes={})
                 journal = Journal.new(attributes)
                 journal.user ||= User.first
                 journal.journalized ||= Issue.first
                 yield journal if block_given?
                 journal.save!
                 journal
               end
               def Version.generate!(attributes={})
                 @generated_version_name ||= 'Version 0'
                 @generated_version_name.succ!
                 version = Version.new(attributes)
                 version.name = @generated_version_name.dup if version.name.blank?
                 version.project ||= Project.find(1)
                 yield version if block_given?
                 version.save!
                 version
               end
               def TimeEntry.generate!(attributes={})
                 entry = TimeEntry.new(attributes)
                 entry.user ||= User.find(2)
                 entry.issue ||= Issue.find(1) unless entry.project
                 entry.project ||= entry.issue.project
                 entry.activity ||= TimeEntryActivity.first
                 entry.spent_on ||= Date.today
                 entry.hours ||= 1.0
                 entry.save!
                 entry
               end
               def AuthSource.generate!(attributes={})
                 @generated_auth_source_name ||= 'Auth 0'
                 @generated_auth_source_name.succ!
                 source = AuthSource.new(attributes)
                 source.name = @generated_auth_source_name.dup if source.name.blank?
                 yield source if block_given?
                 source.save!
                 source
               end
               def Board.generate!(attributes={})
                 @generated_board_name ||= 'Forum 0'
                 @generated_board_name.succ!
                 board = Board.new(attributes)
                 board.name = @generated_board_name.dup if board.name.blank?
                 board.description = @generated_board_name.dup if board.description.blank?
                 yield board if block_given?
                 board.save!
                 board
               end
               def Attachment.generate!(attributes={})
                 @generated_filename ||= 'testfile0'
                 @generated_filename.succ!
                 attributes = attributes.dup
                 attachment = Attachment.new(attributes)
                 attachment.container ||= Issue.find(1)
                 attachment.author ||= User.find(2)
                 attachment.filename = @generated_filename.dup if attachment.filename.blank?
                 attachment.save!
                 attachment
               end
               def CustomField.generate!(attributes={})
                 @generated_custom_field_name ||= 'Custom field 0'
                 @generated_custom_field_name.succ!
                 field = new(attributes)
                 field.name = @generated_custom_field_name.dup if field.name.blank?
                 field.field_format = 'string' if field.field_format.blank?
                 yield field if block_given?
                 field.save!
                 field
               end
               def IssueCustomField.generate!(attributes={})
                 super do |field|
                   field.is_for_all = true unless attributes.key?(:is_for_all)
                   field.tracker_ids = Tracker.all.ids unless attributes.key?(:tracker_ids) || attributes.key?(:trackers)
                 end
               end
               def Changeset.generate!(attributes={})
                 @generated_changeset_rev ||= '123456'
                 @generated_changeset_rev.succ!
                 changeset = new(attributes)
                 changeset.repository ||= Project.find(1).repository
                 changeset.revision ||= @generated_changeset_rev
                 changeset.committed_on ||= Time.now
                 yield changeset if block_given?
                 changeset.save!
                 changeset
               end
               def Query.generate!(attributes={})
                 query = new(attributes)
                 query.name = "Generated query" if query.name.blank?
                 query.user ||= User.find(1)
                 query.save!
                 query
               end
               def generate_import(fixture_name='import_issues.csv')
                 import = IssueImport.new
                 import.user_id = 2
                 import.file = uploaded_test_file(fixture_name, 'text/csv')
                 import.save!
                 import
               end
               def generate_import_with_mapping(fixture_name='import_issues.csv')
                 import = generate_import(fixture_name)
                 import.settings = {
                   'separator' => ";", 'wrapper' => '"', 'encoding' => "UTF-8",
-                  'mapping' => {'project_id' => '1', 'tracker_id' => '2', 'subject' => '1'}
+                  'mapping' => {'project_id' => '1', 'tracker' => '13', 'subject' => '1'}
                 }
                 import.save!
                 import
               end
             end
             module TrackerObjectHelpers
               def generate_transitions!(*args)
                 options = args.last.is_a?(Hash) ? args.pop : {}
                 if args.size == 1
                   args << args.first
                 end
                 if options[:clear]
                   WorkflowTransition.where(:tracker_id => id).delete_all
                 end
                 args.each_cons(2) do |old_status_id, new_status_id|
                   WorkflowTransition.create!(
                     :tracker => self,
                     :role_id => (options[:role_id] || 1),
                     :old_status_id => old_status_id,
                     :new_status_id => new_status_id
                   )
                 end
               end
             end
             Tracker.send :include, TrackerObjectHelpers
             module IssueObjectHelpers
               def close!
                 self.status = IssueStatus.where(:is_closed => true).first
                 save!
               end
               def generate_child!(attributes={})
                 Issue.generate!(attributes.merge(:parent_issue_id => self.id))
               end
             end
             Issue.send :include, IssueObjectHelpers

test/unit/issue_import_test.rb +32 -1

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 File.expand_path('../../test_helper', __FILE__)
             class IssueImportTest < ActiveSupport::TestCase
               fixtures :projects, :enabled_modules,
                        :users, :email_addresses,
                        :roles, :members, :member_roles,
                        :issues, :issue_statuses,
                        :trackers, :projects_trackers,
                        :versions,
                        :issue_categories,
                        :enumerations,
                        :workflows,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_projects,
                        :custom_fields_trackers
               def test_create_versions_should_create_missing_versions
                 import = generate_import_with_mapping
                 import.mapping.merge!('fixed_version' => '9', 'create_versions' => '1')
                 import.save!
                 version = new_record(Version) do
                   assert_difference 'Issue.count', 3 do
                     import.run
                   end
                 end
                 assert_equal '2.1', version.name
               end
               def test_create_categories_should_create_missing_categories
                 import = generate_import_with_mapping
                 import.mapping.merge!('category' => '10', 'create_categories' => '1')
                 import.save!
                 category = new_record(IssueCategory) do
                   assert_difference 'Issue.count', 3 do
                     import.run
                   end
                 end
                 assert_equal 'New category', category.name
               end
+              def test_mapping_with_fixed_tracker
+                import = generate_import_with_mapping
+                import.mapping.merge!('tracker' => 'value:2')
+                import.save!
+                issues = new_records(Issue, 3) { import.run }
+                assert_equal [2], issues.map(&:tracker_id).uniq
+              end
+              def test_mapping_with_mapped_tracker
+                import = generate_import_with_mapping
+                import.mapping.merge!('tracker' => '13')
+                import.save!
+                issues = new_records(Issue, 3) { import.run }
+                assert_equal [1, 2, 1], issues.map(&:tracker_id)
+              end
+              def test_should_not_import_with_default_tracker_when_tracker_is_invalid
+                Tracker.find_by_name('Feature request').update!(:name => 'Feature')
+                import = generate_import_with_mapping
+                import.mapping.merge!('tracker' => '13')
+                import.save!
+                import.run
+                assert_equal 1, import.unsaved_items.count
+                item = import.unsaved_items.first
+                assert_include "Tracker cannot be blank", item.message
+              end
               def test_parent_should_be_set
                 import = generate_import_with_mapping
                 import.mapping.merge!('parent_issue_id' => '5')
                 import.save!
                 issues = new_records(Issue, 3) { import.run }
                 assert_nil issues[0].parent
                 assert_equal issues[0].id, issues[1].parent_id
                 assert_equal 2, issues[2].parent_id
               end
               def test_assignee_should_be_set
                 import = generate_import_with_mapping
                 import.mapping.merge!('assigned_to' => '11')
                 import.save!
                 issues = new_records(Issue, 3) { import.run }
                 assert_equal [User.find(3), nil, nil], issues.map(&:assigned_to)
               end
               def test_user_custom_field_should_be_set
                 field = IssueCustomField.generate!(:field_format => 'user', :is_for_all => true, :trackers => Tracker.all)
                 import = generate_import_with_mapping
                 import.mapping.merge!("cf_#{field.id}" => '11')
                 import.save!
                 issues = new_records(Issue, 3) { import.run }
                 assert_equal '3', issues.first.custom_field_value(field)
               end
               def test_is_private_should_be_set_based_on_user_locale
                 import = generate_import_with_mapping
                 import.mapping.merge!('is_private' => '6')
                 import.save!
                 issues = new_records(Issue, 3) { import.run }
                 assert_equal [false, true, false], issues.map(&:is_private)
               end
               def test_dates_should_be_parsed_using_date_format_setting
                 field = IssueCustomField.generate!(:field_format => 'date', :is_for_all => true, :trackers => Tracker.all)
                 import = generate_import_with_mapping('import_dates.csv')
                 import.settings.merge!('date_format' => Import::DATE_FORMATS[1])
-                import.mapping.merge!('subject' => '0', 'start_date' => '1', 'due_date' => '2', "cf_#{field.id}" => '3')
+                import.mapping.merge!('tracker' => 'value:1', 'subject' => '0', 'start_date' => '1', 'due_date' => '2', "cf_#{field.id}" => '3')
                 import.save!
                 issue = new_record(Issue) { import.run } # only 1 valid issue
                 assert_equal "Valid dates", issue.subject
                 assert_equal Date.parse('2015-07-10'), issue.start_date
                 assert_equal Date.parse('2015-08-12'), issue.due_date
                 assert_equal '2015-07-14', issue.custom_field_value(field)
               end
               def test_date_format_should_default_to_user_language
                 user = User.generate!(:language => 'fr')
                 import = Import.new
                 import.user = user
                 assert_nil import.settings['date_format']
                 import.set_default_settings
                 assert_equal '%d/%m/%Y', import.settings['date_format']
               end
               def test_run_should_remove_the_file
                 import = generate_import_with_mapping
                 file_path = import.filepath
                 assert File.exists?(file_path)
                 import.run
                 assert !File.exists?(file_path)
               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