jro_apps/redmine Commit - r13183:4d6c52a82b44

Use IssueRelation#to_s....

Jean-Philippe Lang -

r13183:4d6c52a82b44

parent child

Context file:

r13183:4d6c52a82b44

Collapse all files

app/helpers/queries_helper.rb +2 -4

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2014  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 QueriesHelper
               include ApplicationHelper
               def filters_options_for_select(query)
                 options_for_select(filters_options(query))
               end
               def filters_options(query)
                 options = [[]]
                 options += query.available_filters.map do |field, field_options|
                   [field_options[:name], field]
                 end
               end
               def query_filters_hidden_tags(query)
                 tags = ''.html_safe
                 query.filters.each do |field, options|
                   tags << hidden_field_tag("f[]", field, :id => nil)
                   tags << hidden_field_tag("op[#{field}]", options[:operator], :id => nil)
                   options[:values].each do |value|
                     tags << hidden_field_tag("v[#{field}][]", value, :id => nil)
                   end
                 end
                 tags
               end
               def query_columns_hidden_tags(query)
                 tags = ''.html_safe
                 query.columns.each do |column|
                   tags << hidden_field_tag("c[]", column.name, :id => nil)
                 end
                 tags
               end
               def query_hidden_tags(query)
                 query_filters_hidden_tags(query) + query_columns_hidden_tags(query)
               end
               def available_block_columns_tags(query)
                 tags = ''.html_safe
                 query.available_block_columns.each do |column|
                   tags << content_tag('label', check_box_tag('c[]', column.name.to_s, query.has_column?(column), :id => nil) + " #{column.caption}", :class => 'inline')
                 end
                 tags
               end
               def query_available_inline_columns_options(query)
                 (query.available_inline_columns - query.columns).reject(&:frozen?).collect {|column| [column.caption, column.name]}
               end
               def query_selected_inline_columns_options(query)
                 (query.inline_columns & query.available_inline_columns).reject(&:frozen?).collect {|column| [column.caption, column.name]}
               end
               def render_query_columns_selection(query, options={})
                 tag_name = (options[:name] || 'c') + '[]'
                 render :partial => 'queries/columns', :locals => {:query => query, :tag_name => tag_name}
               end
               def column_header(column)
                 column.sortable ? sort_header_tag(column.name.to_s, :caption => column.caption,
                                                                     :default_order => column.default_order) :
                                   content_tag('th', h(column.caption))
               end
               def column_content(column, issue)
                 value = column.value_object(issue)
                 if value.is_a?(Array)
                   value.collect {|v| column_value(column, issue, v)}.compact.join(', ').html_safe
                 else
                   column_value(column, issue, value)
                 end
               end
               def column_value(column, issue, value)
                 case column.name
                 when :id
                   link_to value, issue_path(issue)
                 when :subject
                   link_to value, issue_path(issue)
                 when :parent
                   value ? (value.visible? ? link_to_issue(value, :subject => false) : "##{value.id}") : ''
                 when :description
                   issue.description? ? content_tag('div', textilizable(issue, :description), :class => "wiki") : ''
                 when :done_ratio
                   progress_bar(value, :width => '80px')
                 when :relations
-                  other = value.other_issue(issue)
                   content_tag('span',
-                    (l(value.label_for(issue)) + " " + link_to_issue(other, :subject => false, :tracker => false)).html_safe,
+                    value.to_s(issue) {|other| link_to_issue(other, :subject => false, :tracker => false)}.html_safe,
                     :class => value.css_classes_for(issue))
                 else
                   format_object(value)
                 end
               end
               def csv_content(column, issue)
                 value = column.value_object(issue)
                 if value.is_a?(Array)
                   value.collect {|v| csv_value(column, issue, v)}.compact.join(', ')
                 else
                   csv_value(column, issue, value)
                 end
               end
               def csv_value(column, object, value)
                 format_object(value, false) do |value|
                   case value.class.name
                   when 'Float'
                     sprintf("%.2f", value).gsub('.', l(:general_csv_decimal_separator))
                   when 'IssueRelation'
-                    other = value.other_issue(object)
+                    value.to_s(object)
-                    l(value.label_for(object)) + " ##{other.id}"
                   when 'Issue'
                     if object.is_a?(TimeEntry)
                       "#{value.tracker} ##{value.id}: #{value.subject}"
                     else
                       value.id
                     end
                   else
                     value
                   end
                 end
               end
               def query_to_csv(items, query, options={})
                 encoding = l(:general_csv_encoding)
                 columns = (options[:columns] == 'all' ? query.available_inline_columns : query.inline_columns)
                 query.available_block_columns.each do |column|
                   if options[column.name].present?
                     columns << column
                   end
                 end
                 export = CSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
                   # csv header fields
                   csv << columns.collect {|c| Redmine::CodesetUtil.from_utf8(c.caption.to_s, encoding) }
                   # csv lines
                   items.each do |item|
                     csv << columns.collect {|c| Redmine::CodesetUtil.from_utf8(csv_content(c, item), encoding) }
                   end
                 end
                 export
               end
               # Retrieve query from session or build a new query
               def retrieve_query
                 if !params[:query_id].blank?
                   cond = "project_id IS NULL"
                   cond << " OR project_id = #{@project.id}" if @project
                   @query = IssueQuery.where(cond).find(params[:query_id])
                   raise ::Unauthorized unless @query.visible?
                   @query.project = @project
                   session[:query] = {:id => @query.id, :project_id => @query.project_id}
                   sort_clear
                 elsif api_request? || params[:set_filter] || session[:query].nil? || session[:query][:project_id] != (@project ? @project.id : nil)
                   # Give it a name, required to be valid
                   @query = IssueQuery.new(:name => "_")
                   @query.project = @project
                   @query.build_from_params(params)
                   session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names}
                 else
                   # retrieve from session
                   @query = nil
                   @query = IssueQuery.find_by_id(session[:query][:id]) if session[:query][:id]
                   @query ||= IssueQuery.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
                   @query.project = @project
                 end
               end
               def retrieve_query_from_session
                 if session[:query]
                   if session[:query][:id]
                     @query = IssueQuery.find_by_id(session[:query][:id])
                     return unless @query
                   else
                     @query = IssueQuery.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
                   end
                   if session[:query].has_key?(:project_id)
                     @query.project_id = session[:query][:project_id]
                   else
                     @query.project = @project
                   end
                   @query
                 end
               end
             end

app/models/issue_relation.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2014  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 IssueRelation < ActiveRecord::Base
               # Class used to represent the relations of an issue
               class Relations < Array
                 include Redmine::I18n
                 def initialize(issue, *args)
                   @issue = issue
                   super(*args)
                 end
                 def to_s(*args)
-                  map {|relation| "#{l(relation.label_for(@issue))} ##{relation.other_issue(@issue).id}"}.join(', ')
+                  map {|relation| relation.to_s(@issue)}.join(', ')
                 end
               end
               belongs_to :issue_from, :class_name => 'Issue'
               belongs_to :issue_to, :class_name => 'Issue'
               TYPE_RELATES      = "relates"
               TYPE_DUPLICATES   = "duplicates"
               TYPE_DUPLICATED   = "duplicated"
               TYPE_BLOCKS       = "blocks"
               TYPE_BLOCKED      = "blocked"
               TYPE_PRECEDES     = "precedes"
               TYPE_FOLLOWS      = "follows"
               TYPE_COPIED_TO    = "copied_to"
               TYPE_COPIED_FROM  = "copied_from"
               TYPES = {
                 TYPE_RELATES =>     { :name => :label_relates_to, :sym_name => :label_relates_to,
                                       :order => 1, :sym => TYPE_RELATES },
                 TYPE_DUPLICATES =>  { :name => :label_duplicates, :sym_name => :label_duplicated_by,
                                       :order => 2, :sym => TYPE_DUPLICATED },
                 TYPE_DUPLICATED =>  { :name => :label_duplicated_by, :sym_name => :label_duplicates,
                                       :order => 3, :sym => TYPE_DUPLICATES, :reverse => TYPE_DUPLICATES },
                 TYPE_BLOCKS =>      { :name => :label_blocks, :sym_name => :label_blocked_by,
                                       :order => 4, :sym => TYPE_BLOCKED },
                 TYPE_BLOCKED =>     { :name => :label_blocked_by, :sym_name => :label_blocks,
                                       :order => 5, :sym => TYPE_BLOCKS, :reverse => TYPE_BLOCKS },
                 TYPE_PRECEDES =>    { :name => :label_precedes, :sym_name => :label_follows,
                                       :order => 6, :sym => TYPE_FOLLOWS },
                 TYPE_FOLLOWS =>     { :name => :label_follows, :sym_name => :label_precedes,
                                       :order => 7, :sym => TYPE_PRECEDES, :reverse => TYPE_PRECEDES },
                 TYPE_COPIED_TO =>   { :name => :label_copied_to, :sym_name => :label_copied_from,
                                       :order => 8, :sym => TYPE_COPIED_FROM },
                 TYPE_COPIED_FROM => { :name => :label_copied_from, :sym_name => :label_copied_to,
                                       :order => 9, :sym => TYPE_COPIED_TO, :reverse => TYPE_COPIED_TO }
               }.freeze
               validates_presence_of :issue_from, :issue_to, :relation_type
               validates_inclusion_of :relation_type, :in => TYPES.keys
               validates_numericality_of :delay, :allow_nil => true
               validates_uniqueness_of :issue_to_id, :scope => :issue_from_id
               validate :validate_issue_relation
               attr_protected :issue_from_id, :issue_to_id
               before_save :handle_issue_order
               after_create  :call_issues_relation_added_callback
               after_destroy :call_issues_relation_removed_callback
               def visible?(user=User.current)
                 (issue_from.nil? || issue_from.visible?(user)) && (issue_to.nil? || issue_to.visible?(user))
               end
               def deletable?(user=User.current)
                 visible?(user) &&
                   ((issue_from.nil? || user.allowed_to?(:manage_issue_relations, issue_from.project)) ||
                     (issue_to.nil? || user.allowed_to?(:manage_issue_relations, issue_to.project)))
               end
               def initialize(attributes=nil, *args)
                 super
                 if new_record?
                   if relation_type.blank?
                     self.relation_type = IssueRelation::TYPE_RELATES
                   end
                 end
               end
               def validate_issue_relation
                 if issue_from && issue_to
                   errors.add :issue_to_id, :invalid if issue_from_id == issue_to_id
                   unless issue_from.project_id == issue_to.project_id ||
                             Setting.cross_project_issue_relations?
                     errors.add :issue_to_id, :not_same_project
                   end
                   # detect circular dependencies depending wether the relation should be reversed
                   if TYPES.has_key?(relation_type) && TYPES[relation_type][:reverse]
                     errors.add :base, :circular_dependency if issue_from.all_dependent_issues.include? issue_to
                   else
                     errors.add :base, :circular_dependency if issue_to.all_dependent_issues.include? issue_from
                   end
                   if issue_from.is_descendant_of?(issue_to) || issue_from.is_ancestor_of?(issue_to)
                     errors.add :base, :cant_link_an_issue_with_a_descendant
                   end
                 end
               end
               def other_issue(issue)
                 (self.issue_from_id == issue.id) ? issue_to : issue_from
               end
               # Returns the relation type for +issue+
               def relation_type_for(issue)
                 if TYPES[relation_type]
                   if self.issue_from_id == issue.id
                     relation_type
                   else
                     TYPES[relation_type][:sym]
                   end
                 end
               end
               def label_for(issue)
                 TYPES[relation_type] ?
                     TYPES[relation_type][(self.issue_from_id == issue.id) ? :name : :sym_name] :
                     :unknow
               end
               def to_s(issue=nil)
                 issue ||= issue_from
                 issue_text = block_given? ? yield(other_issue(issue)) : "##{other_issue(issue).try(:id)}"
                 s = []
                 s << l(label_for(issue))
                 s << "(#{l('datetime.distance_in_words.x_days', :count => delay)})" if delay && delay != 0
                 s << issue_text
                 s.join(' ')
               end
               def css_classes_for(issue)
                 "rel-#{relation_type_for(issue)}"
               end
               def handle_issue_order
                 reverse_if_needed
                 if TYPE_PRECEDES == relation_type
                   self.delay ||= 0
                 else
                   self.delay = nil
                 end
                 set_issue_to_dates
               end
               def set_issue_to_dates
                 soonest_start = self.successor_soonest_start
                 if soonest_start && issue_to
                   issue_to.reschedule_on!(soonest_start)
                 end
               end
               def successor_soonest_start
                 if (TYPE_PRECEDES == self.relation_type) && delay && issue_from &&
                        (issue_from.start_date || issue_from.due_date)
                   (issue_from.due_date || issue_from.start_date) + 1 + delay
                 end
               end
               def <=>(relation)
                 r = TYPES[self.relation_type][:order] <=> TYPES[relation.relation_type][:order]
                 r == 0 ? id <=> relation.id : r
               end
               def init_journals(user)
                 issue_from.init_journal(user) if issue_from
                 issue_to.init_journal(user) if issue_to
               end
               private
               # Reverses the relation if needed so that it gets stored in the proper way
               # Should not be reversed before validation so that it can be displayed back
               # as entered on new relation form
               def reverse_if_needed
                 if TYPES.has_key?(relation_type) && TYPES[relation_type][:reverse]
                   issue_tmp = issue_to
                   self.issue_to = issue_from
                   self.issue_from = issue_tmp
                   self.relation_type = TYPES[relation_type][:reverse]
                 end
               end
               def call_issues_relation_added_callback
                 call_issues_callback :relation_added
               end
               def call_issues_relation_removed_callback
                 call_issues_callback :relation_removed
               end
               def call_issues_callback(name)
                 [issue_from, issue_to].each do |issue|
                   if issue
                     issue.send name, self
                   end
                 end
               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