redmine_extensions 0.1.14 → 0.1.15

data/spec/redmine/app/helpers/imports_helper.rb

@@ -0,0 +1,47 @@
+# 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)} --" : " ".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), :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

data/spec/redmine/app/models/custom_field_enumeration.rb

@@ -0,0 +1,90 @@
+# 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 CustomFieldEnumeration < ActiveRecord::Base
+  include Redmine::SafeAttributes
+
+  belongs_to :custom_field
+  attr_accessible :name, :active, :position
+
+  validates_presence_of :name, :position, :custom_field_id
+  validates_length_of :name, :maximum => 60
+  validates_numericality_of :position, :only_integer => true
+  before_create :set_position
+
+  scope :active, lambda { where(:active => true) }
+
+  safe_attributes 'name',
+    'active',
+    'position'
+
+  def to_s
+    name.to_s
+  end
+
+  def objects_count
+    custom_values.count
+  end
+
+  def in_use?
+    objects_count > 0
+  end
+
+  alias :destroy_without_reassign :destroy
+  def destroy(reassign_to=nil)
+    if reassign_to
+      custom_values.update_all(:value => reassign_to.id.to_s)
+    end
+    destroy_without_reassign
+  end
+
+  def custom_values
+    custom_field.custom_values.where(:value => id.to_s)
+  end
+
+  def self.update_each(custom_field, attributes)
+    return unless attributes.is_a?(Hash)
+    transaction do
+      attributes.each do |enumeration_id, enumeration_attributes|
+        enumeration = custom_field.enumerations.find_by_id(enumeration_id)
+        if enumeration
+          if block_given?
+            yield enumeration, enumeration_attributes
+          else
+            enumeration.attributes = enumeration_attributes
+          end
+          unless enumeration.save
+            raise ActiveRecord::Rollback
+          end
+        end
+      end
+    end
+  end
+
+  def self.fields_for_order_statement(table=nil)
+    table ||= table_name
+    columns = ['position']
+    columns.uniq.map {|field| "#{table}.#{field}"}
+  end
+
+  private
+
+  def set_position
+    max = self.class.where(:custom_field_id => custom_field_id).maximum(:position) || 0
+    self.position = max + 1
+  end
+end

data/spec/redmine/app/models/import.rb

@@ -0,0 +1,249 @@
+# 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 Import < ActiveRecord::Base
+  has_many :items, :class_name => 'ImportItem', :dependent => :delete_all
+  belongs_to :user
+  serialize :settings
+
+  before_destroy :remove_file
+
+  validates_presence_of :filename, :user_id
+  validates_length_of :filename, :maximum => 255
+
+  DATE_FORMATS = [
+    '%Y-%m-%d',
+    '%d/%m/%Y',
+    '%m/%d/%Y',
+    '%d.%m.%Y',
+    '%d-%m-%Y'
+  ]
+
+  def initialize(*args)
+    super
+    self.settings ||= {}
+  end
+
+  def file=(arg)
+    return unless arg.present? && arg.size > 0
+
+    self.filename = generate_filename
+    Redmine::Utils.save_upload(arg, filepath)
+  end
+
+  def set_default_settings
+    separator = lu(user, :general_csv_separator)
+    if file_exists?
+      begin
+        content = File.read(filepath, 256)
+        separator = [',', ';'].sort_by {|sep| content.count(sep) }.last
+      rescue Exception => e
+      end
+    end
+    wrapper = '"'
+    encoding = lu(user, :general_csv_encoding)
+
+    date_format = lu(user, "date.formats.default", :default => "foo")
+    date_format = DATE_FORMATS.first unless DATE_FORMATS.include?(date_format)
+
+    self.settings.merge!(
+      'separator' => separator,
+      'wrapper' => wrapper,
+      'encoding' => encoding,
+      'date_format' => date_format
+    )
+  end
+
+  def to_param
+    filename
+  end
+
+  # Returns the full path of the file to import
+  # It is stored in tmp/imports with a random hex as filename
+  def filepath
+    if filename.present? && filename =~ /\A[0-9a-f]+\z/
+      File.join(Rails.root, "tmp", "imports", filename)
+    else
+      nil
+    end
+  end
+
+  # Returns true if the file to import exists
+  def file_exists?
+    filepath.present? && File.exists?(filepath)
+  end
+
+  # Returns the headers as an array that
+  # can be used for select options
+  def columns_options(default=nil)
+    i = -1
+    headers.map {|h| [h, i+=1]}
+  end
+
+  # Parses the file to import and updates the total number of items
+  def parse_file
+    count = 0
+    read_items {|row, i| count=i}
+    update_attribute :total_items, count
+    count
+  end
+
+  # Reads the items to import and yields the given block for each item
+  def read_items
+    i = 0
+    headers = true
+    read_rows do |row|
+      if i == 0 && headers
+        headers = false
+        next
+      end
+      i+= 1
+      yield row, i if block_given?
+    end
+  end
+
+  # Returns the count first rows of the file (including headers)
+  def first_rows(count=4)
+    rows = []
+    read_rows do |row|
+      rows << row
+      break if rows.size >= count
+    end
+    rows
+  end
+
+  # Returns an array of headers
+  def headers
+    first_rows(1).first || []
+  end
+
+  # Returns the mapping options
+  def mapping
+    settings['mapping'] || {}
+  end
+
+  # Imports items and returns the position of the last processed item
+  def run(options={})
+    max_items = options[:max_items]
+    max_time = options[:max_time]
+    current = 0
+    imported = 0
+    resume_after = items.maximum(:position) || 0
+    interrupted = false
+    started_on = Time.now
+
+    read_items do |row, position|
+      if (max_items && imported >= max_items) || (max_time && Time.now >= started_on + max_time)
+        interrupted = true
+        break
+      end
+      if position > resume_after
+        item = items.build
+        item.position = position
+
+        if object = build_object(row)
+          if object.save
+            item.obj_id = object.id
+          else
+            item.message = object.errors.full_messages.join("\n")
+          end
+        end
+
+        item.save!
+        imported += 1
+      end
+      current = position
+    end
+
+    if imported == 0 || interrupted == false
+      if total_items.nil?
+        update_attribute :total_items, current
+      end
+      update_attribute :finished, true
+      remove_file
+    end
+
+    current
+  end
+
+  def unsaved_items
+    items.where(:obj_id => nil)
+  end
+
+  def saved_items
+    items.where("obj_id IS NOT NULL")
+  end
+
+  private
+
+  def read_rows
+    return unless file_exists?
+
+    csv_options = {:headers => false}
+    csv_options[:encoding] = settings['encoding'].to_s.presence || 'UTF-8'
+    separator = settings['separator'].to_s
+    csv_options[:col_sep] = separator if separator.size == 1
+    wrapper = settings['wrapper'].to_s
+    csv_options[:quote_char] = wrapper if wrapper.size == 1
+
+    CSV.foreach(filepath, csv_options) do |row|
+      yield row if block_given?
+    end
+  end
+
+  def row_value(row, key)
+    if index = mapping[key].presence
+      row[index.to_i].presence
+    end
+  end
+
+  def row_date(row, key)
+    if s = row_value(row, key)
+      format = settings['date_format']
+      format = DATE_FORMATS.first unless DATE_FORMATS.include?(format)
+      Date.strptime(s, format) rescue s
+    end
+  end
+
+  # Builds a record for the given row and returns it
+  # To be implemented by subclasses
+  def build_object(row)
+  end
+
+  # Generates a filename used to store the import file
+  def generate_filename
+    Redmine::Utils.random_hex(16)
+  end
+
+  # Deletes the import file
+  def remove_file
+    if file_exists?
+      begin
+        File.delete filepath
+      rescue Exception => e
+        logger.error "Unable to delete file #{filepath}: #{e.message}" if logger
+      end
+    end
+  end
+
+  # Returns true if value is a string that represents a true value
+  def yes?(value)
+    value == lu(user, :general_text_yes) || value == '1'
+  end
+end

data/spec/redmine/app/models/import_item.rb

@@ -0,0 +1,22 @@
+# 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 ImportItem < ActiveRecord::Base
+  belongs_to :import
+
+  validates_presence_of :import_id, :position
+end

data/spec/redmine/app/models/issue_import.rb

@@ -0,0 +1,186 @@
+# 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
+    if mapping['tracker'].to_s =~ /\Avalue:(\d+)\z/
+      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' => tracker_id,
+      'subject' => row_value(row, 'subject'),
+      'description' => row_value(row, 'description')
+    }
+    if status_name = row_value(row, 'status')
+      if status_id = IssueStatus.named(status_name).first.try(:id)
+        attributes['status_id'] = status_id
+      end
+    end
+    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