0001-YetAnotherUpdate-Of-Ported-the_redmine_subtasks-plugin_from_Aleksei_Guse.patch - Redmine

       before_filter :find_issue, :only => [:show, :edit, :reply]
       before_filter :find_issues, :only => [:bulk_edit, :move, :destroy]
       before_filter :find_project, :only => [:new, :update_form, :preview]
       before_filter :authorize, :except => [:index, :changes, :gantt, :calendar, :preview, :context_menu]
       before_filter :find_project, :only => [:new, :update_form, :preview, :add_subissue, :auto_complete_for_issue_parent]
       before_filter :authorize, :except => [:index, :changes, :gantt, :calendar, :preview, :context_menu, :add_subissue]
       before_filter :find_optional_project, :only => [:index, :changes, :gantt, :calendar]
       before_filter :find_parent_issue, :only => [:add_subissue]
       before_filter :find_optional_parent_issue, :only => [:new, :update_form]
       accept_key_auth :index, :show, :changes
       rescue_from Query::StatementInvalid, :with => :query_statement_invalid
-...
       include IssuesHelper
       helper :timelog
       include Redmine::Export::PDF
       include ActionView::Helpers::PrototypeHelper
       verify :method => :post,
              :only => :destroy,
-...
       end
       def show
         retrieve_query_for_subissues
         @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
         @journals.each_with_index {|j,i| j.indice = i+1}
         @journals.reverse! if User.current.wants_comments_in_reverse_order?
-...
           # Check that the user is allowed to apply the requested status
           @issue.status = (@allowed_statuses.include? requested_status) ? requested_status : default_status
           call_hook(:controller_issues_new_before_save, { :params => params, :issue => @issue })
           @issue.parent_id = params[:issue][:parent_id] if params[:issue]
           if @issue.save
             attach_files(@issue, params[:attachments])
             flash[:notice] = l(:notice_successful_create)
-...
         end
         if request.post?
           @issue.parent_id = params[:issue][:parent_id] if params[:issue] && params[:issue][:parent_id]
           @time_entry = TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => Date.today)
           @time_entry.attributes = params[:time_entry]
           if (@time_entry.hours.nil? || @time_entry.valid?) && @issue.valid?
-...
         attachments.each(&:destroy)
       end
       def add_subissue
         redirect_to :action => 'new',
                     :project_id => @parent_issue.project,
                     :issue => { :parent_id => @parent_issue.id }
       end
       def reply
         journal = Journal.find(params[:journal_id]) if params[:journal_id]
         if journal
-...
                                   :order => "start_date, effective_date",
                                   :conditions => ["(((start_date>=? and start_date<=?) or (effective_date>=? and effective_date<=?) or (start_date<? and effective_date>?)) and start_date is not null and due_date is null and effective_date is not null)", @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to]
+                                  )
           # Parent issues that might not have the due_date set but do have
           # child issues that do have due_date set should be included.
           events.each do |issue|
             if issue.leaf?
               # Can't use the Issue#visible named_scope because it causes
               # a SQL error with the awesome_nested_set
               ancestors = issue.ancestors.all(:include => [:tracker, :assigned_to, :priority, :project],
                                               :order => "start_date",
                                               :conditions => 'start_date IS NOT NULL')
               ancestors.map! {|i| i.visible? ? i : nil }.compact!
               events += ancestors.flatten if ancestors.present?
             end
           end
           # Versions
           events += @query.versions(:conditions => ["effective_date BETWEEN ? AND ?", @gantt.date_from, @gantt.date_to])
           @gantt.events = events
           @gantt.events = events.uniq
         end
         basename = (@project ? "#{@project.identifier}-" : '') + 'gantt'
-...
         @text = params[:notes] || (params[:issue] ? params[:issue][:description] : nil)
         render :partial => 'common/preview'
       end
       def auto_complete_for_issue_parent
         @phrase = params[:issue_parent]
         @candidates = []
         # If cross project issue relations is allowed we should get
         # candidates from every project
         if Setting.cross_project_issue_relations?
           projects_to_search = nil
         else
           projects_to_search = [ @project ] + @project.children
         end
         if @phrase.present?
           # Try to find issue by id.
           if @phrase.match(/^#?(\d+)$/)
             if Setting.cross_project_issue_relations?
               issue = Issue.visible.find_by_id( $1)
             else
               issue = Issue.visible.find_by_id_and_project_id( $1, projects_to_search.collect { |i| i.id})
             end
             @candidates << issue if issue
           end
           # Search by subject and description
           # extract tokens from the question
           # eg. hello "bye bye" => ["hello", "bye bye"]
           tokens = @phrase.scan(%r{((\s|^)"[\s\w]+"(\s|$)|\S+)}).collect {|m| m.first.gsub(%r{(^\s*"\s*|\s*"\s*$)}, '')}
           # tokens must be at least 3 character long
           tokens = tokens.uniq.select {|w| w.length > 2 }
           like_tokens = tokens.collect {|w| "%#{w.downcase}%"}
           search_results, count = Issue.search( like_tokens, projects_to_search, :before => true, :limit => 10)
           @candidates += search_results unless search_results.empty?
         end
         # Remove the current issue if it's a result
         if params[:id].present?
           @issue = Issue.visible.find_by_id(params[:id])
           @candidates.delete(@issue)
         end
         render :inline => "<%= auto_complete_result_parent_issue( @candidates, @phrase) %>"
       end
     private
       def find_issue
         @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
         @project = @issue.project
         @parent_issue = @issue.parent if @issue
       rescue ActiveRecord::RecordNotFound
         render_404
       end
       def find_parent_issue
         @parent_issue = Issue.find( params[:parent_issue_id])
         render_404 unless @parent_issue.visible?(User.current)
       rescue ActiveRecord::RecordNotFound
         render_404
       end
       def find_optional_parent_issue
         if params[:issue] && !params[:issue][:parent_id].blank?
           @parent_issue = Issue.visible.find_by_id( params[:issue][:parent_id])
         end
       end
       # Filter for bulk operations
       def find_issues
-...
             end
             @query.group_by = params[:group_by]
             @query.column_names = params[:query] && params[:query][:column_names]
             session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names}
             if params[:view_options] and params[:view_options].is_a? Hash
               params[:view_options].each_pair do |name, value|
                 @query.set_view_option( name, value)
               end
             end
             session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names, :view_options => @query.view_options}
           else
             @query = Query.find_by_id(session[:query][:id]) if session[:query][:id]
             @query ||= Query.new(:name => "_", :project => @project, :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
             if session[:query][:view_options]
               session[:query][:view_options].each_pair do |name, value|
                 @query.set_view_option( name, value)
               end
             end
             @query.project = @project
           end
         end
       end
       # Retrive and build a query for the subissues
       def retrieve_query_for_subissues
         retrieve_query
         @query.project = @project
         @query.set_view_option('show_parents', ViewOption::SHOW_PARENTS[:organize_by])
         @query.column_names = Setting.subissues_list_columns
         sort_init( @query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
         sort_update({'id' => "#{Issue.table_name}.id"}.merge( @query.available_columns.inject({}) { |h, c| h[c.name.to_s] = c.sortable; h}))
       end
       # Rescues an invalid query statement. Just in case...
       def query_statement_invalid(exception)

       helper :repositories
       include RepositoriesHelper
       include ProjectsHelper
       helper :versions
       include VersionsHelper
       # Lists visible projects
       def index

b/app/controllers/queries_controller.rb
31	31	@query.add_filter(field, params[:operators][field], params[:values][field])
32	32	end if params[:fields]
33	33	@query.group_by \|\|= params[:group_by]
	34	@query.view_options = params[:view_options] if params[:view_options]
34	35
35	36	if request.post? && params[:confirm] && @query.save
36	37	flash[:notice] = l(:notice_successful_create)

           when 'estimated_hours'
             value = "%0.02f" % detail.value.to_f unless detail.value.blank?
             old_value = "%0.02f" % detail.old_value.to_f unless detail.old_value.blank?
           when 'parent_id'
             if detail.value && i = Issue.visible.find_by_id(detail.value)
               value = i.subject
             end
             if detail.old_value && i = Issue.visible.find_by_id(detail.old_value)
               old_value = i.subject
             end
             label = l(:field_parent_issue)
           end
         when 'cf'
           custom_field = CustomField.find_by_id(detail.prop_key)
-...
         end
         export
       end
       def auto_complete_result_parent_issue(candidates, phrase)
         if candidates.present?
           candidates.map! do |c|
             content_tag("li",
                         highlight( c.to_s, phrase),
                         :id => String( c[:id]))
           end
         else
           candidates = [content_tag(:li, l(:label_none), :style => 'display:none')]
         end
         content_tag("ul", candidates.uniq)
       end
     end

                           content_tag('th', column.caption)
       end
       def column_content(column, issue)
       def column_content(column, issue, query = nil)
         value = column.value(issue)
         case value.class.name
         when 'String'
           if column.name == :subject
             link_to(h(value), :controller => 'issues', :action => 'show', :id => issue)
             subject_in_tree( issue, issue.subject, query)
           else
             h(value)
           end
-...
           h(value)
         end
       end
       def subject_in_tree(issue, value, query)
         if query.view_options['show_parents'] == ViewOption::SHOW_PARENTS[:never]
           content_tag('div', subject_text(issue, value), :class=>'issue-subject')
         else
           css_style = "margin-left: #{issue.level}em;" # Used to indent
           content_tag('span',
                       content_tag('div',
                                   subject_text(issue, value),
                                   :class=>'issue-subject',
                                   :style => css_style),
                       :class => issue.level > 0 ? "issue-subject-in-tree issue-level-#{issue.level}" : '',
                       :style => css_style)
         end
       end
       def subject_text(issue, value)
         if issue.visible?
           subject_text = link_to(h(value), :controller => 'issues', :action => 'show', :id => issue)
           h((@project.nil? || @project != issue.project) ? "#{issue.project.name} - " : '') + subject_text
         else
           h(value)
         end
       end
       def issue_content(issue, query, options = { })
         row_classes = ['issue','hascontextmenu', issue.css_classes, cycle('odd', 'even')]
         row_classes << 'issue-unfiltered' if options[:unfiltered]
         row_classes << 'issue-emphasis' if options[:emphasis]
         inner_content = returning '' do |content|
           content << content_tag(:td, check_box_tag("ids[]", issue.id, false, :id => nil), :class => 'checkbox')
           content << content_tag(:td, link_to(issue.id, :controller => 'issues', :action => 'show', :id => issue))
           query.columns.each do |column|
             content << content_tag( 'td', column_content(column, issue, query), :class => column.name)
           end
         end
         content_tag(:tr,
                     inner_content,
                     :id => "issue-#{issue.id}",
                     :class => row_classes.join(' '))
       end
       def private_issue_content(issue, query, options = { })
         row_classes = ['issue', 'private-issue',cycle('odd', 'even')]
         row_classes << 'issue-unfiltered' if options[:unfiltered]
         row_classes << 'issue-emphasis' if options[:emphasis]
         inner_content = returning '' do |content|
           content << content_tag(:td, check_box_tag("ids[]", '', false, :id => nil), :class => 'checkbox')
           content << content_tag(:td, l(:text_private))
           query.columns.each do |column|
             if column.name == :subject
               # Need to indent
               content << content_tag('td', subject_in_tree(issue, l(:text_private), query), :class => column.name)
             else
               content << content_tag( 'td', l(:text_private), :class => column.name)
             end
           end
         end
         content_tag(:tr,
                     inner_content,
                     :id => "",
                     :class => row_classes.join(' '))
       end
       def issues_family_content( parent, issues_to_show, query, emphasis_issues)
         html = ""
         if parent.visible?
           html << issue_content( parent, query, :unfiltered => !( issues_to_show.include? parent),
                                  :emphasis => ( emphasis_issues ? emphasis_issues.include?( parent) : false))
         else
           html << private_issue_content( parent, query, :unfiltered => !( issues_to_show.include? parent),
                                          :emphasis => ( emphasis_issues ? emphasis_issues.include?( parent) : false))
         end
         unless  parent.children.empty?
           parent.children.each do |child|
             if issues_to_show.include?( child) || issues_to_show.detect { |i| i.ancestors.include? child }
               html << issues_family_content( child, issues_to_show, query, emphasis_issues)
             end
           end
         end
         html
       end
     end

       def status_by_options_for_select(value)
         options_for_select(STATUS_BY_CRITERIAS.collect {|criteria| [l("field_#{criteria}".to_sym), criteria]}, value)
       end
       def render_list_of_related_issues( issues, version, current_level = 0)
         issues_on_current_level = issues.select { |i| i.level == current_level }
         issues -= issues_on_current_level
         content_tag( 'ul') do
           html = ''
           issues_on_current_level.each do |issue|
             opts_for_issue_li = { }
             if !issue.fixed_version or issue.fixed_version != version
               opts_for_issue_li[:class] = 'issue-unfiltered'
             end
             html << content_tag( 'li', opts_for_issue_li) do
               opts = { }
               if issue.done_ratio == 100
                 opts[:style] = 'font-weight: bold'
               end
               link_to_issue(issue, opts)
             end
             children_to_print = issues & issue.children
             children_to_print += issues.select { |i| i.level >= current_level + 2}
             unless children_to_print.empty?
               html << render_list_of_related_issues( children_to_print, version, current_level + 1)
             end
           end
           html
         end
       end
     end

       acts_as_customizable
       acts_as_watchable
       acts_as_searchable :columns => ['subject', "#{table_name}.description", "#{Journal.table_name}.notes"],
                          :include => [:project, :journals],
                          :include => [:project, :journals, :tracker],
                          # sort by id so that limited eager loading doesn't break with postgresql
                          :order_column => "#{table_name}.id"
       acts_as_event :title => Proc.new {|o| "#{o.tracker.name} ##{o.id} (#{o.status}): #{o.subject}"},
-...
       acts_as_activity_provider :find_options => {:include => [:project, :author, :tracker]},
                                 :author_key => :author_id
       DONE_RATIO_OPTIONS = %w(issue_field issue_status)
       # Needs to be registered before any before_destroy in acts_as_nested_set
       before_destroy :move_children_to_root_before_destroy
       acts_as_nested_set
       # Patches to acts_as_nested_set since Issue already defines #move_to
       def move_to_left_of(node)
         nested_set_move_to node, :left
       end
       def move_to_right_of(node)
         nested_set_move_to node, :right
       end
       def move_to_child_of(node)
         nested_set_move_to node, :child
       end
       def move_to_root
         nested_set_move_to nil, :root
       end
       alias_method :nested_set_move_to, :move_to
       DONE_RATIO_OPTIONS = %w(issue_field issue_status)
       validates_presence_of :subject, :priority, :project, :tracker, :author, :status
       validates_length_of :subject, :maximum => 255
       validates_inclusion_of :done_ratio, :in => 0..100
       validates_numericality_of :estimated_hours, :allow_nil => true
       validate :subtasks_validation
       named_scope :visible, lambda {|*args| { :include => :project,
                                               :conditions => Project.allowed_to_condition(args.first || User.current, :view_issues) } }
-...
       before_save :update_done_ratio_from_issue_status
       after_save :create_journal
       after_save :set_parent
       after_save :do_subtasks_hooks
       # Returns true if usr or current user is allowed to view the issue
       def visible?(usr=nil)
-...
       # Returns the moved/copied issue on success, false on failure
       def move_to(new_project, new_tracker = nil, options = {})
         options ||= {}
         issue = options[:copy] ? self.clone : self
         issue = if options[:copy]
                   Issue.new( self.attributes.reject { |k,v| k == 'parent_id' })
                 else
                   self
                 end
         transaction do
           if new_project && issue.project_id != new_project.id
             # delete issue relations
             unless Setting.cross_project_issue_relations?
               issue.relations_from.clear
               issue.relations_to.clear
               issue.children.each(&:move_to_root) unless options[:copy]
             end
             # issue is moved to another project
             # reassign to the category with same name if any
-...
               # Manually update project_id on related time entries
               TimeEntry.update_all("project_id = #{new_project.id}", {:issue_id => id})
             end
             if new_project && issue.project_id != new_project.id && !Setting.cross_project_issue_relations?
               issue.move_to_root
             end
           else
             Issue.connection.rollback_db_transaction
             return false
-...
         end
         return issue
       end
       # Cache awesome_nested_set's level attribute, it goes back to the
       # database and counts ancestors which can be expensive.
       def level
         unless @level
           @level = super
         end
         @level
       end
       def priority_id=(pid)
         self.priority = nil
         write_attribute(:priority_id, pid)
-...
       end
       alias_method_chain :attributes=, :tracker_first
       # Need to define the setter because awesome_nested_set removes the
       # parent_id setter since parent is an internal field.  If parent
       # isn't set though, then parent changes will not be logged to journals.
       def parent_id=(pid)
         if pid != id
           write_attribute(:parent_id, pid)
         else
           false # Circular reference
         end
       end
       def estimated_hours
         if leaf?
           read_attribute(:estimated_hours)
         else
           children.inject(0) do |sum, issue|
             if issue.estimated_hours.present?
               sum + issue.estimated_hours
             else
               sum
             end
           end
         end
       end
        # Returns the estimated_hours, disregarding child issues
        def original_estimated_hours
          read_attribute(:estimated_hours)
        end
       def estimated_hours=(h)
         write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h)
         write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h) if leaf?
       end
       def due_date
         if leaf?
           read_attribute( :due_date)
         else
           unless @due_date # cache, expensive operation
             dates = leaves.map(&:due_date)
             @due_date = dates.select {|d| d }.max if (dates && dates.any?)
           end
           @due_date
         end
       end
       [ :due_date, :done_ratio ].each do |method|
         src = <<-END_SRC
           def #{method}=(value)
             write_attribute( :#{method}, value) if leaf?
           end
           END_SRC
         class_eval src, __FILE__, __LINE__
       end
       def done_ratio
         if Issue.use_status_for_done_ratio? && status && status.default_done_ratio?
           status.default_done_ratio
         if leaf?
           if Issue.use_status_for_done_ratio? && status && status.default_done_ratio?
             status.default_done_ratio
           else
             read_attribute(:done_ratio)
           end
         else
           read_attribute(:done_ratio)
           unless @done_ratio # cache, expensive operation
             if Issue.use_status_for_done_ratio?
               total_done_ratio=children.inject(0) {|sum, i| sum + i.done_ratio}
               if total_done_ratio == 0
                 @done_ratio = 0
               else
                 @done_ratio = (total_done_ratio / children.size )
               end
             else
               total_planned_days = leaves.inject(0) {|sum,i| sum + i.duration}
               if total_planned_days == 0
                 @done_ratio = 0
               else
                 total_actual_days = leaves.inject(0) {|sum,i| sum + i.actual_days}
                 @done_ratio = (total_actual_days * 100 / total_planned_days).floor
               end
             end
           end
           @done_ratio
         end
       end
-...
       end
       def validate
         if self.due_date.nil? && @attributes['due_date'] && !@attributes['due_date'].empty?
         if self.due_date.nil? && @attributes['due_date'] && !@attributes['due_date'].empty? && leaf?
           errors.add :due_date, :not_a_date
         end
-...
         # Update start/due dates of following issues
         relations_from.each(&:set_issue_to_dates)
         # If target version is set, but "Due to" date is not, set
         # it as the same as the date of target version.
         if leaf? && due_date.nil? && fixed_version && fixed_version.due_date
           self.update_attribute :due_date, fixed_version.due_date
         end
         # Close duplicates if the issue was closed
         if @issue_before_change && !@issue_before_change.closed? && self.closed?
           duplicates.each do |duplicate|
-...
         updated_on_will_change!
         @current_journal
       end
       def journal_initilized?
         @current_journal
       end
       # Return true if the issue is closed, otherwise false
       def closed?
         self.status.is_closed?
       end
       def open?
         !closed?
       end
       # Return true if the issue is being reopened
       def reopened?
-...
       def soonest_start
         @soonest_start ||= relations_to.collect{|relation| relation.successor_soonest_start}.compact.min
       end
       # Returns the number of days that have been worked on this issue.
       # Calculated by using the duration of the issue (start/end dates)
       # and the done ratio
       def actual_days
         if done_ratio
           (duration * done_ratio / 100).floor
         else
         end
       end
       def to_s
         "#{tracker} ##{id}: #{subject}"
-...
         Issue.update_versions(["#{Version.table_name}.project_id IN (?) OR #{Issue.table_name}.project_id IN (?)", moved_project_ids, moved_project_ids])
       end
       def leaf?
         new_record? || (right - left == 1)
       end
       private
       # Update issues so their versions are not pointing to a
-...
                   :include => [:project, :fixed_version]
                   ).each do |issue|
           next if issue.project.nil? || issue.fixed_version.nil?
           unless issue.project.shared_versions.include?(issue.fixed_version)
           unless issue.project.shared_versions.collect(&:id).include?(issue.fixed_version_id)
             issue.init_journal(User.current)
             issue.fixed_version = nil
             issue.save
-...
       def create_journal
         if @current_journal
           # attributes changes
           (Issue.column_names - %w(id description lock_version created_on updated_on)).each {|c|
           skip_attrs = %w(id description lock_version created_on updated_on)
           skip_attrs += %w(due_date done_ratio estimated_hours) unless leaf?
           # attributes changes
           (Issue.column_names - skip_attrs).each {|c|
             @current_journal.details << JournalDetail.new(:property => 'attr',
                                                           :prop_key => c,
                                                           :old_value => @issue_before_change.send(c),
-...
           @current_journal.save
         end
       end
       def move_children_to_root_before_destroy
         unless Setting.delete_children?
           children.each( &:move_to_root)
           reload_nested_set
         end
       end
       def do_subtasks_hooks
         if parent
           # Need to reload the Issues.  Using the association or
           # parent.reload was keeping the object readonly.
           parent_issue = Issue.find parent.id
           self.reload
           # Update the parent status if this issue is open and the parent
           # is closed
           if open? && parent_issue.closed?
             parent_issue.init_journal(User.current)
             parent_issue.status = IssueStatus.find_by_id(Setting.reopened_parent_issue_status) || IssueStatus.default
           end
           # Set 'Target version' of parent if one was set on one of the
           # children issue and parent have no 'Target version'. Do the same
           # if 'Target version of the parent issue lower (by the release
           # date or by the version number).
           if parent_issue.fixed_version.nil? && fixed_version or
               ( parent_issue.fixed_version && fixed_version and
                 parent_issue.fixed_version.project == fixed_version.project and
                 parent_issue.fixed_version < fixed_version )
             parent_issue.init_journal(User.current) unless parent_issue.journal_initilized?
             parent_issue.fixed_version = fixed_version
           end
           parent_issue.save if parent_issue.changed?
         end
       end
       def set_parent
         if (@issue_before_change && @issue_before_change.parent_id != parent_id) ||
             self.lock_version == 0 # Newly saved record
           if parent_id.present?
             parent_issue = Issue.visible.find_by_id(parent_id)
             move_to_child_of parent_issue if parent_issue
           else
             move_to_root
           end
         end
       end
       def subtasks_validation
         unless children.empty?
           if IssueStatus.find_by_id( @attributes['status_id']).is_closed? && children.detect { |i| !i.closed? }
             errors.add( :status, l(:error_issue_subtasks_cant_close_parent))
           end
           children_max_fixed_version = children.select { |i| i.fixed_version } .max { |a,b| a.fixed_version <=> b.fixed_version }
           if @attributes['fixed_version_id'] && children_max_fixed_version
             if Version.find_by_id( @attributes['fixed_version_id']) < children_max_fixed_version.fixed_version
               errors.add :fixed_version, l(:error_issue_subtasks_cant_select_lower_target_version)
             end
           end
         end
       end
     end

       serialize :filters
       serialize :column_names
       serialize :sort_criteria, Array
       serialize :view_options
       attr_protected :project_id, :user_id
-...
         QueryColumn.new(:created_on, :sortable => "#{Issue.table_name}.created_on", :default_order => 'desc'),
+      ]
       cattr_reader :available_columns
       @@available_view_options =
         [ ViewOption.new( 'show_parents',
                           [ [ l(:label_view_option_parents_do_not_show),
                               ViewOption::SHOW_PARENTS[:never] ],
                             [ l(:label_view_option_parents_show_always),
                               ViewOption::SHOW_PARENTS[:always] ],
                             [ l(:label_view_option_parents_show_and_group),
                               ViewOption::SHOW_PARENTS[:organize_by]]])
+        ]
       cattr_reader :available_view_options
       def initialize(attributes = nil)
         super attributes
         self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }
         self.view_options ||=  { 'show_parents' => 'do_not_show' }
       end
       def after_initialize
-...
       rescue ::ActiveRecord::StatementInvalid => e
         raise StatementInvalid.new(e.message)
       end
       def set_view_option( option, value)
         self.view_options[option] = value
         # Clear group_by if organize_by_parent is selected
         if option == 'show_parents' && value == 'organize_by_parent'
           self.group_by = nil
         end
       end
       def values_for_view_option( option)
         @@available_view_options.find { |vo| vo.name == option }.available_values
       end
       def caption_for_view_option( option)
         @@available_view_options.find { |vo| vo.name == option }.caption
       end
       private

     # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     class Version < ActiveRecord::Base
       include Comparable
       before_destroy :check_integrity
       after_update :update_issues_from_sharing_change
       belongs_to :project

     class ViewOption
       attr_accessor :name, :available_values
       include Redmine::I18n
       unless const_defined? :SHOW_PARENTS
         SHOW_PARENTS = { :never       => 'do_not_show',
                          :always      => 'show_always',
                          :organize_by => 'organize_by_parent'}.freeze
       end
       def initialize( name, available_values)
         self.name = name
         self.available_values = available_values
       end
       def caption
         l("label_view_option_#{name}")
       end
     end

     <div class="contextual">
     <%= link_to_if_authorized(l(:button_update), {:controller => 'issues', :action => 'edit', :id => @issue }, :onclick => 'showAndScrollTo("update", "notes"); return false;', :class => 'icon icon-edit', :accesskey => accesskey(:edit)) %>
     <%= link_to_if_authorized(l(:button_add_subissue),
+                              {
                               :controller => 'issues',
                               :action => 'add_subissue',
                               :project_id => @project,
                               :parent_issue_id => @issue.id
                             },
                             :class => 'icon icon-add') %>
     <%= link_to_if_authorized l(:button_log_time), {:controller => 'timelog', :action => 'edit', :issue_id => @issue}, :class => 'icon icon-time-add' %>
     <% replace_watcher ||= 'watcher' %>
     <%= watcher_tag(@issue, User.current, {:id => replace_watcher, :replace => ['watcher','watcher2']}) %>

     </div>
     <div class="splitcontentright">
     <% if @issue.new_record? ||  @issue.leaf? %>
     <p><%= f.text_field :start_date, :size => 10 %><%= calendar_for('issue_start_date') %></p>
     <p><%= f.text_field :due_date, :size => 10 %><%= calendar_for('issue_due_date') %></p>
     <p><%= f.text_field :estimated_hours, :size => 3 %> <%= l(:field_hours) %></p>
     <% if Issue.use_field_for_done_ratio? %>
     <p><%= f.select :done_ratio, ((0..10).to_a.collect {|r| ["#{r*10} %", r*10] }) %></p>
     <% end %>
     <% else %>
     <p><label><%= l(:field_start_date) %></label> <%= format_date(@issue.start_date) %></p>
     <p><label><%= l(:field_due_date) %></label> <%= format_date(@issue.due_date) %></p>
     <p><label><%= l(:field_done_ratio) %></label> <%= "#{@issue.done_ratio}%" %></p>
     <% end %>
     </div>
     <div>
     <%= render :partial => 'parent_field' %>
     </div>
     <div style="clear:both;"> </div>

     	</tr></thead>
     	<% previous_group = false %>
     	<tbody>
     	<% issues.each do |issue| -%>
       <% if @query.grouped? && (group = @query.group_by_column.value(issue)) != previous_group %>
         <% reset_cycle %>
         <tr class="group open">
         	<td colspan="<%= query.columns.size + 2 %>">
         		<span class="expander" onclick="toggleRowGroup(this); return false;">&nbsp;</span>
           	<%= group.blank? ? 'None' : column_content(@query.group_by_column, issue) %> <span class="count">(<%= @issue_count_by_group[group] %>)</span>
         	</td>
     		</tr>
     		<% previous_group = group %>
       <% end %>
     	<tr id="issue-<%= issue.id %>" class="hascontextmenu <%= cycle('odd', 'even') %> <%= issue.css_classes %>">
     	    <td class="checkbox"><%= check_box_tag("ids[]", issue.id, false, :id => nil) %></td>
     		<td><%= link_to issue.id, :controller => 'issues', :action => 'show', :id => issue %></td>
             <% query.columns.each do |column| %><%= content_tag 'td', column_content(column, issue), :class => column.name %><% end %>
     	</tr>
     	<% end -%>
           <% emphasis_issues ||= [] %>
           <% if query.view_options['show_parents'] == ViewOption::SHOW_PARENTS[:organize_by] -%>
             <%= render :partial => 'list_organized_by_parent', :locals => { :issues => issues, :query => query, :emphasis_issues => emphasis_issues }%>
           <% else %>
           <% issues.each do |issue| -%>
             <% if @query.grouped? && (group = @query.group_by_column.value(issue)) != previous_group %>
               <% reset_cycle %>
               <tr class="group open">
                 <td colspan="<%= query.columns.size + 2 %>">
     		  <span class="expander" onclick="toggleRowGroup(this); return false;">&nbsp;</span>
                   <%= group.blank? ? 'None' : column_content(@query.group_by_column, issue) %> <span class="count">(<%= @issue_count_by_group[group] %>)</span>
                 </td>
               </tr>
               <% previous_group = group %>
             <% end %>
             <% if query.view_options['show_parents'] == ViewOption::SHOW_PARENTS[:always] -%>
               <% issue.ancestors.each do |parent_issue| -%>
                 <% if parent_issue.visible? %>
                   <%= issue_content( parent_issue, query, :unfiltered => true) %>
                 <% else %>
                   <%= private_issue_content( parent_issue, query, :unfiltered => true) %>
                 <% end %>
               <% end -%>
             <% end %>
             <%= issue_content( issue, query, :emphasis => ( emphasis_issues ? emphasis_issues.include?( issue) : false)) %>
           <% end -%>
           <% end -%>
     	</tbody>
     </table>
     <% end -%>

     <%-
     parents_on_first_lvl = []
     issues.each do |i|
       if i.parent
         first_parent = i.root
       else
         first_parent = i
       end
       parents_on_first_lvl += [ first_parent ] unless parents_on_first_lvl.include?( first_parent)
     end
     parents_on_first_lvl.each do |parent| -%>
     <%= issues_family_content( parent, issues, query, emphasis_issues) %>
     <% end -%>

     <%= hidden_field_tag('issue[parent_id]', (@parent_issue ? @parent_issue.id : ""), :id => :issue_parent_id) %>
     <p><label><%= l(:field_parent_issue) %></label>
     <% if authorize_for( 'issues', 'auto_complete_for_issue_parent') %>
       <% if @parent_issue && @parent_issue.visible? %>
         <%= text_field_tag( 'parent_issue', '', :value => @parent_issue) %>
       <% else %>
         <%= text_field_tag( 'parent_issue', '', :value => @parent_issue ? l(:text_private) : '') %>
       <% end %>
       <%= link_to_function( "Remove", 'clearValues(["issue_parent_id", "parent_issue"])') %>
       <div id="parent_issue_candidates" class="autocomplete"></div>
       <%= javascript_tag "observeParentIssueField('#{url_for(:controller => :issues,
                                                              :action => :auto_complete_for_issue_parent,
                                                              :id => @issue.id,
                                                              :project_id => @project.id) }')" %>
     <% else %>
       <%= @parent_issue || "-" %>
     <% end %>
     </p>

     <% if @issue.root.self_and_descendants.size > 1 %>
       <% content_for :header_tags do %>
         <%= javascript_include_tag 'context_menu' %>
         <%= stylesheet_link_tag 'context_menu' %>
       <% end %>
     	<hr />
       <p><strong><%=l(:label_issues_hierarchy)%></strong></p>
       <div id="subissues">
     		<%= render( :partial => 'issues/list',
     								:locals => {
     									:issues 				 => @issue.root.self_and_descendants,
     									:emphasis_issues => [ @issue ],
     									:query  				 => @query }) %>
       </div>
       <div id="context-menu" style="display: none;"></div>
       <%= javascript_tag "new ContextMenu('#{url_for(:controller => 'issues', :action => 'context_menu')}')" %>
     <% end %>

     		<ul>
     		<% (0..10).map{|x|x*10}.each do |p| -%>
     		    <li><%= context_menu_link "#{p}%", {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), 'done_ratio' => p, :back_url => @back}, :method => :post,
     		                                  :selected => (@issue && p == @issue.done_ratio), :disabled => !@can[:edit] %></li>
     		                                  :selected => (@issue && p == @issue.done_ratio), :disabled => (!@can[:edit] || !@issues.all? {|i| i.leaf? }) %></li>
     		<% end -%>
     		</ul>
     	</li>

     						<td><%= l(:field_group_by) %></td>
     						<td><%= select_tag('group_by', options_for_select([[]] + @query.groupable_columns.collect {|c| [c.caption, c.name.to_s]}, @query.group_by)) %></td>
     					</tr>
                         <% @query.view_options.each_key do |voption| -%>
                         <tr>
                           <td><%= @query.caption_for_view_option(voption) %></td>
                           <td><%= select_tag( "view_options[#{voption}]", options_for_select(@query.values_for_view_option(voption), @query.view_options[voption])) %></td>
                         </tr>
                         <% end %>
     				</table>
     			</div>
     		</fieldset>

         <th class="estimated-hours"><%=l(:field_estimated_hours)%>:</th><td class="estimated-hours"><%= l_hours(@issue.estimated_hours) %></td>
         <% end %>
     </tr>
     <% if !@issue.leaf? && @issue.original_estimated_hours %>
        <td colspan="2">&nbsp;</td>
        <th class="estimated-hours"><%=l(:field_original_estimated_hours)%>:</th><td class="estimated-hours"><%= l_hours(@issue.original_estimated_hours) %></td>
     <% end %>
     <%= render_custom_fields_rows(@issue) %>
     <%= call_hook(:view_issues_show_details_bottom, :issue => @issue) %>
     </table>
-...
     <%= link_to_attachments @issue %>
     <%= render :partial => 'subissues_list' %>
     <%= call_hook(:view_issues_show_description_bottom, :issue => @issue) %>
     <% if authorize_for('issue_relations', 'new') || @issue.relations.any? %>

         <%= render(:partial => "wiki/content", :locals => {:content => version.wiki_page.content}) if version.wiki_page %>
         <% if (issues = @issues_by_version[version]) && issues.size > 0 %>
         <% issues.each do |i|
              issues += i.ancestors if i.child?
            end
            issues.uniq! %>
         <fieldset class="related-issues"><legend><%= l(:label_related_issues) %></legend>
         <ul>
         <%- issues.each do |issue| -%>
             <li><%= link_to_issue(issue, :project => (@project != issue.project)) %></li>
         <%- end -%>
         <%= render_list_of_related_issues( issues, version) %>
         </ul>
         </fieldset>
         <% end %>

     <p><label for="query_group_by"><%= l(:field_group_by) %></label>
     <%= select 'query', 'group_by', @query.groupable_columns.collect {|c| [c.caption, c.name.to_s]}, :include_blank => true %></p>
     <% @query.view_options.each_key do |voption| -%>
     <p><label><%= @query.caption_for_view_option(voption) %></label>
     <%= select_tag("view_options[#{voption}]", options_for_select(@query.values_for_view_option(voption), @query.view_options[voption])) %></p>
     <% end %>
     <p><label for="query_group_by"><%= l(:field_group_by) %></label>
     <%= select 'query', 'group_by', @query.groupable_columns.collect {|c| [c.caption, c.name.to_s]}, :include_blank => true %></p>
     </div>
     <fieldset><legend><%= l(:label_filter_plural) %></legend>

     <p><%= setting_select :issue_done_ratio, Issue::DONE_RATIO_OPTIONS.collect {|i| [l("setting_issue_done_ratio_#{i}"), i]} %></p>
     <p><%= setting_text_field :issues_export_limit, :size => 6 %></p>
     <p><%= setting_select :delete_children, [ [l(:general_text_Yes), "1" ], [l(:general_text_No),  "0" ] ] %></p>
     <p><%= setting_select :reopened_parent_issue_status, [["", 0]] + IssueStatus.all(:order => 'position ASC').collect{|status| [status.name, status.id.to_s]} %></p>
     </div>
     <fieldset class="box settings"><legend><%= l(:setting_issue_list_default_columns) %></legend>
-...
             Query.new.available_columns.collect {|c| [c.caption, c.name.to_s]}, :label => false) %>
     </fieldset>
     <fieldset class="box settings"><legend><%= l(:setting_subissues_list_columns) %></legend>
     <%= setting_multiselect(:subissues_list_columns, Query.new.available_columns.collect {|c| [c.caption, c.name.to_s]}, :label => false) %>
     </fieldset>
     <%= submit_tag l(:button_save) %>
     <% end %>

     <%= render(:partial => "wiki/content", :locals => {:content => @version.wiki_page.content}) if @version.wiki_page %>
     <% issues = @version.fixed_issues.find(:all,
                                            :include => [:status, :tracker, :priority],
                                            :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id") %>
                                            :include => [:status, :tracker, :priority, :fixed_version],
                                            :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id")
            issues ||= []
            issues.each do |i|
              issues += i.ancestors if i.child?
            end
            issues.uniq!
     %>
     <% if issues.size > 0 %>
     <fieldset class="related-issues"><legend><%= l(:label_related_issues) %></legend>
     <ul>
     <% issues.each do |issue| -%>
         <li><%= link_to_issue(issue) %></li>
     <% end -%>
     </ul>
       <%= render_list_of_related_issues( issues, @version) %>
     </fieldset>
     <% end %>
     </div>

       error_issue_done_ratios_not_updated: "Issue done ratios not updated."
       error_workflow_copy_source: 'Please select a source tracker or role'
       error_workflow_copy_target: 'Please select target tracker(s) and role(s)'
       error_issue_subtasks_cant_close_parent: "Can't close parent issue while one of the children is still open."
       error_issue_subtasks_cant_select_lower_target_version: "Can't set target version of parent issue lower than any of the children."
       warning_attachments_not_saved: "{{count}} file(s) could not be saved."
-...
       field_assignable: Issues can be assigned to this role
       field_redirect_existing_links: Redirect existing links
       field_estimated_hours: Estimated time
       field_original_estimated_hours: Original estimated time
       field_column_names: Columns
       field_time_zone: Time zone
       field_searchable: Searchable
-...
       field_content: Content
       field_group_by: Group results by
       field_sharing: Sharing
       field_parent_issue: Child of
       setting_app_title: Application title
       setting_app_subtitle: Application subtitle
-...
       setting_issue_done_ratio_issue_status: Use the issue status
       setting_start_of_week: Start calendars on
       setting_rest_api_enabled: Enable REST web service
       setting_subissues_list_columns: Columns for subissues list
       setting_delete_children: Delete children when parent destroyed
       setting_reopened_parent_issue_status: Status applied to parent when reopening
       permission_add_project: Create project
       permission_add_subprojects: Create subprojects
-...
       label_api_access_key: API access key
       label_missing_api_access_key: Missing an API access key
       label_api_access_key_created_on: "API access key created {{value}} ago"
       label_view_option_parents_do_not_show: Never
       label_view_option_parents_show_always: Always
       label_view_option_parents_show_and_group: Organize by parent
       label_issues_hierarchy: Issues hierarchy
       label_view_option_show_parents: Show parents
       button_login: Login
       button_submit: Submit
-...
       button_quote: Quote
       button_duplicate: Duplicate
       button_show: Show
       button_add_subissue: Add sub-issue
       status_active: active
       status_registered: registered
-...
       text_wiki_page_destroy_children: "Delete child pages and all their descendants"
       text_wiki_page_reassign_children: "Reassign child pages to this parent page"
       text_own_membership_delete_confirmation: "You are about to remove some or all of your permissions and may no longer be able to edit this project after that.\nAre you sure you want to continue?"
       text_private: Private
       default_role_manager: Manager
       default_role_developper: Developer

       default: ''
     rest_api_enabled:
       default: 0
     delete_children:
       default: 1
     subissues_list_columns:
       serialized: true
       default:
       - id
       - subject
       - status
       - start_date
       - due_date
     reopened_parent_issue_status:
       default: ''

     class AddQueriesViewOptions < ActiveRecord::Migration
       def self.up
         add_column :queries, :view_options, :text
       end
       def self.down
         remove_column :queries, :view_options
       end
     end

     class AddDefaultValueOfViewOptoinsQueries < ActiveRecord::Migration
       def self.up
         Query.find(:all).each do |q|
           q.view_options ||= { 'show_parents' => 'do_not_show' }
           q.save!
         end
       end
       def self.down
       end
     end

     class AddIssuesParentIdLftAndRgt < ActiveRecord::Migration
       def self.up
         add_column :issues, :parent_id, :integer, :default => nil
         add_column :issues, :lft, :integer
         add_column :issues, :rgt, :integer
       end
       def self.down
         remove_column :issues, :parent_id
         remove_column :issues, :lft
         remove_column :issues, :rgt
       end
     end

     # Need to assume Issues are valid in order to rebuild.
     class Issue < ActiveRecord::Base
       def valid?
         true
       end
     end
     class IssuesRebuild < ActiveRecord::Migration
       def self.up
         Issue.rebuild!
       end
       def self.down
       end
     end

     class AddLftRgtIndexesToIssues < ActiveRecord::Migration
       def self.up
         add_index :issues, :lft
         add_index :issues, :rgt
       end
       def self.down
         remove_index :issues, :lft
         remove_index :issues, :rgt
       end
     end

     class AddIndexesToIssuesParentId < ActiveRecord::Migration
       def self.up
         add_index :issues, :parent_id
       end
       def self.down
         remove_index :issues, :parent_id
       end
     end

                                       :reports => :issue_report}
         map.permission :add_issues, {:issues => [:new, :update_form]}
         map.permission :edit_issues, {:issues => [:edit, :reply, :bulk_edit, :update_form]}
         map.permission :manage_issue_relations, {:issue_relations => [:new, :destroy]}
         map.permission :manage_issue_relations, {:issue_relations => [:new, :destroy], :issues => [:add_subissue, :auto_complete_for_issue_parent]}
         map.permission :add_issue_notes, {:issues => [:edit, :reply]}
         map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
         map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin