Redmine

    @target_project ||= @project    

    @trackers = @target_project.trackers

    @available_statuses = Workflow.available_statuses(@project)

    @notes = params[:notes]

    @notes ||= ''

  end

  def extract_changed_attributes_for_move(params)

    changed_attributes = {}

      unless params[valid_attribute].blank?

        changed_attributes[valid_attribute] = (params[valid_attribute] == 'none' ? nil : params[valid_attribute])

      end

      @issue_count = @query.issue_count

      @issue_pages = Paginator.new self, @issue_count, @limit, params['page']

      @offset ||= @issue_pages.current.offset

                              :order => sort_clause, 

                              :offset => @offset, 

                              :limit => @limit)

    @subprojects = @project.descendants.visible

    @issues_by_tracker = Issue.by_tracker(@project)

    @issues_by_priority = Issue.by_priority(@project)

    @issues_by_category = Issue.by_category(@project)

    @issues_by_assigned_to = Issue.by_assigned_to(@project)

      @rows = @project.trackers

      @data = Issue.by_tracker(@project)

      @report_title = l(:field_tracker)

      @field = "fixed_version_id"

      @rows = @project.shared_versions.sort

    when "priority"

      @field = "priority_id"

      @rows = IssuePriority.all

        value = format_date(detail.value.to_date) if detail.value

        old_value = format_date(detail.old_value.to_date) if detail.old_value

        value = find_name_by_reflection(field, detail.value)

        old_value = find_name_by_reflection(field, detail.old_value)

                  l(:field_subject),

                  l(:field_assigned_to),

                  l(:field_category),

                  l(:field_fixed_version),

                  l(:field_author),

                  l(:field_start_date),

                  issue.subject,

                  issue.assigned_to,

                  issue.category,

                  issue.fixed_version,

                  issue.author.name,

                  format_date(issue.start_date),

  belongs_to :status, :class_name => 'IssueStatus', :foreign_key => 'status_id'

  belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'

  belongs_to :assigned_to, :class_name => 'User', :foreign_key => 'assigned_to_id'

  belongs_to :fixed_version, :class_name => 'Version', :foreign_key => 'fixed_version_id'

  belongs_to :priority, :class_name => 'IssuePriority', :foreign_key => 'priority_id'

  belongs_to :category, :class_name => 'IssueCategory', :foreign_key => 'category_id'

  attr_reader :current_journal

  validates_presence_of :subject, :priority, :project, :tracker, :author, :status

  validates_length_of :subject, :maximum => 255

  validates_inclusion_of :done_ratio, :in => 0..100

      # reassign to the category with same name if any

      new_category = issue.category.nil? ? nil : new_project.issue_categories.find_by_name(issue.category.name)

      issue.category = new_category

      unless new_project.shared_versions.include?(issue.fixed_version)

        issue.fixed_version = nil

      end

    'category_id',

    'assigned_to_id',

    'priority_id',

    'fixed_version_id',

    'subject',

    'description',

      errors.add :start_date, :invalid

    end

    if fixed_version

        errors.add :fixed_version_id, :inclusion

      elsif reopened? && fixed_version.closed?

        errors.add_to_base I18n.t(:error_can_not_reopen_issue_on_closed_version)

    users.uniq.sort

  end

  end

  # Returns true if this issue is blocked by another issue that is still open

  # Unassigns issues from +version+ if it's no longer shared with issue's project

  def self.update_versions_from_sharing_change(version)

    # Update issues assigned to the version

    update_versions(["#{Issue.table_name}.fixed_version_id = ?", version.id])

  end

                       :joins => Tracker.table_name)

  end

    count_and_group_by(:project => project,

                       :field => 'fixed_version_id',

                       :joins => Version.table_name)

        issue.save

      end

    end

  end

  # Callback on attachment deletion

      'priority_id' => (k = get_keyword(:priority)) && IssuePriority.find_by_name(k).try(:id),

      'category_id' => (k = get_keyword(:category)) && issue.project.issue_categories.find_by_name(k).try(:id),

      'assigned_to_id' => assigned_to.try(:id),

      'fixed_version_id' => (k = get_keyword(:fixed_version, :override => true)) && issue.project.shared_versions.find_by_name(k).try(:id),

      'start_date' => get_keyword(:start_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),

      'due_date' => get_keyword(:due_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),

      new_issue = Issue.new

      new_issue.copy_from(issue)

      new_issue.project = self

      # project and the versions for self are not yet saved

      if issue.fixed_version

        new_issue.fixed_version = self.versions.select {|v| v.name == issue.fixed_version.name}.first

      end

    QueryColumn.new(:assigned_to, :sortable => ["#{User.table_name}.lastname", "#{User.table_name}.firstname", "#{User.table_name}.id"], :groupable => true),

    QueryColumn.new(:updated_on, :sortable => "#{Issue.table_name}.updated_on", :default_order => 'desc'),

    QueryColumn.new(:category, :sortable => "#{IssueCategory.table_name}.name", :groupable => true),

    QueryColumn.new(:fixed_version, :sortable => ["#{Version.table_name}.effective_date", "#{Version.table_name}.name"], :default_order => 'desc', :groupable => true),

    QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),

    QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),

    @available_filters = { "status_id" => { :type => :list_status, :order => 1, :values => IssueStatus.find(:all, :order => 'position').collect{|s| [s.name, s.id.to_s] } },       

                           "tracker_id" => { :type => :list, :order => 2, :values => trackers.collect{|s| [s.name, s.id.to_s] } },                                                                                                                

                           "priority_id" => { :type => :list, :order => 3, :values => IssuePriority.all.collect{|s| [s.name, s.id.to_s] } },

    user_values = []

    user_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?

    @available_filters["assigned_to_role"] = { :type => :list_optional, :order => 7, :values => role_values } unless role_values.empty?

    if User.current.logged?

    end

    if project

        @available_filters["category_id"] = { :type => :list_optional, :order => 6, :values => @project.issue_categories.collect{|s| [s.name, s.id.to_s] } }

      end

      unless @project.shared_versions.empty?

      end

      unless @project.descendants.active.empty?

      end

      add_custom_fields_filters(@project.all_issue_custom_fields)

    else

      # global filters for cross project issue list

      system_shared_versions = Version.visible.find_all_by_sharing('system')

      unless system_shared_versions.empty?

      end

      add_custom_fields_filters(IssueCustomField.find(:all, :conditions => {:is_filter => true, :is_for_all => true}))

    end

class Version < ActiveRecord::Base

  after_update :update_issues_from_sharing_change

  belongs_to :project

  has_many :fixed_issues, :class_name => 'Issue', :foreign_key => 'fixed_version_id', :dependent => :nullify

  acts_as_customizable

  acts_as_attachable :view_permission => :view_files,

  validates_inclusion_of :sharing, :in => VERSION_SHARINGS

  named_scope :open, :conditions => {:status => 'open'}

  named_scope :visible, lambda {|*args| { :include => :project,

                                          :conditions => Project.allowed_to_condition(args.first || User.current, :view_issues) } }

  <%= select_tag('status_id', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(@available_statuses, :id, :name)) %>

</p>

<p>

  <label><%= l(:field_priority) %></label>

  <%= select_tag('priority_id', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(IssuePriority.all, :id, :name)) %>

                     :title => l(:label_issue_category_new), 

                     :tabindex => 199) if authorize_for('issue_categories', 'new') %></p>

<% end %>

<%= prompt_to_remote(image_tag('add.png', :style => 'vertical-align: middle;'),

                     l(:label_version_new),

                     'version[name]', 

<% if Issue.use_field_for_done_ratio? %>

<p><%= f.select :done_ratio, ((0..10).to_a.collect {|r| ["#{r*10} %", r*10] }) %></p>

<% end %>

<% end %>

</div>

</div>

<% #TODO: allow editing versions when multiple projects %>

<% if @project %>

<p>

	<label><%= l(:field_fixed_version) %></label> 

	<%= select_tag('issue[fixed_version_id]', content_tag('option', l(:label_no_change_option), :value => '') +

                                   content_tag('option', l(:label_none), :value => 'none') +

</p>

<% end %>

      api.author(:id => issue.author_id, :name => issue.author.name) unless issue.author.nil?

      api.assigned_to(:id => issue.assigned_to_id, :name => issue.assigned_to.name) unless issue.assigned_to.nil?

      api.category(:id => issue.category_id, :name => issue.category.name) unless issue.category.nil?

      api.fixed_version(:id => issue.fixed_version_id, :name => issue.fixed_version.name) unless issue.fixed_version.nil?

      api.parent(:id => issue.parent_id) unless issue.parent.nil?

  api.author(:id => @issue.author_id, :name => @issue.author.name) unless @issue.author.nil?

  api.assigned_to(:id => @issue.assigned_to_id, :name => @issue.assigned_to.name) unless @issue.assigned_to.nil?

  api.category(:id => @issue.category_id, :name => @issue.category.name) unless @issue.category.nil?

  api.fixed_version(:id => @issue.fixed_version_id, :name => @issue.fixed_version.name) unless @issue.fixed_version.nil?

  api.parent(:id => @issue.parent_id) unless @issue.parent.nil?

    <% end %>

</tr>

<tr>

    <% if @issue.estimated_hours %>

    <th class="estimated-hours"><%=l(:field_estimated_hours)%>:</th><td class="estimated-hours"><%= l_hours(@issue.estimated_hours) %></td>

    <% end %>

</tr>

<%= render_custom_fields_rows(@issue) %>

<%= call_hook(:view_issues_show_details_bottom, :issue => @issue) %>

</table>

<li><%=l(:field_priority)%>: <%=h issue.priority %></li>

<li><%=l(:field_assigned_to)%>: <%=h issue.assigned_to %></li>

<li><%=l(:field_category)%>: <%=h issue.category %></li>

<li><%=l(:field_fixed_version)%>: <%=h issue.fixed_version %></li>

<% issue.custom_values.each do |c| %>

  <li><%=h c.custom_field.name %>: <%=h show_value(c) %></li>

<%=l(:field_priority)%>: <%= issue.priority %>

<%=l(:field_assigned_to)%>: <%= issue.assigned_to %>

<%=l(:field_category)%>: <%= issue.category %>

<%=l(:field_fixed_version)%>: <%= issue.fixed_version %>

<% issue.custom_values.each do |c| %><%= c.custom_field.name %>: <%= show_value(c) %>

<% end %>

</div>

<div class="splitcontentright">

<br />

<% if @project.children.any? %>

<h3><%=l(:field_subproject)%>&nbsp;&nbsp;<%= link_to image_tag('zoom_in.png'), :action => 'issue_report_details', :detail => 'subproject' %></h3>

  field_due_date: Due date

  field_assigned_to: Assignee

  field_priority: Priority

  field_fixed_version: Target version

  field_user: User

  field_principal: Principal