Redmine

      end

    end

  end

end

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

module QueriesHelper

  def filters_options_for_select(query)

    options_for_select(filters_options(query))

  end

  end

  def column_content(column, issue)

    if value.is_a?(Array)

      value.collect {|v| column_value(column, issue, v)}.compact.join(', ').html_safe

    else

      link_to value, issue_path(issue)

    when :subject

      link_to value, issue_path(issue)

    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,

        :class => value.css_classes_for(issue))

      format_object(value)

  end

  def csv_content(column, issue)

    if value.is_a?(Array)

      value.collect {|v| csv_value(column, issue, v)}.compact.join(', ')

      csv_value(column, issue, value)

  end

    end

  end

    object.send name

  end

  def css_classes

    name

  end

    @cf

  end

    if custom_field.visible_by?(object.project, User.current)

    else

      nil

  end

  end

  def css_classes

    @association = association

  end

    if assoc = object.send(@association)

      super(assoc)

    end

  after_save do |query|

    if query.visibility_changed? && query.visibility != VISIBILITY_ROLES

  end

  class_attribute :operators

  self.operators = {

    "="   => :label_equals,

    "*"   => :label_any,

    "><t+"=> :label_in_the_next_days,

    "ld"  => :label_yesterday,

    "lw"  => :label_last_week,

    "l2w" => [:label_last_n_weeks, {:count => 2}],

    "m"   => :label_this_month,

    "lm"  => :label_last_month,

    "y"   => :label_this_year,

    "><t-"=> :label_in_the_past_days,

    "!~"  => :label_not_contains,

    "=p"  => :label_any_issues_in_project,

    "=!p" => :label_any_issues_not_in_project,

  class_attribute :operators_by_filter_type

  self.operators_by_filter_type = {

    :list => [ "=", "!" ],

    :date => [ "=", ">=", "<=", "><", "<t+", ">t+", "><t+", "t+", "t", "ld", "w", "lw", "l2w", "m", "lm", "y", ">t-", "<t-", "><t-", "t-", "!*", "*" ],

    :date_past => [ "=", ">=", "<=", "><", ">t-", "<t-", "><t-", "t-", "t", "ld", "w", "lw", "l2w", "m", "lm", "y", "!*", "*" ],

    :float => [ "=", ">=", "<=", "><", "!*", "*" ],

    :relation => ["=", "=p", "=!p", "!p", "!*", "*"]

  }

    json = {}

    available_filters.each do |field, options|

      json[field] = options.slice(:type, :name, :values).stringify_keys

    json

  def all_projects

    @all_projects ||= Project.visible.all

  def all_projects_values

    return @all_projects_values if @all_projects_values

    values = []

      values << ["#{prefix}#{p.name}", p.id.to_s]

    @all_projects_values = values

  # Adds available filters

  def initialize_available_filters

    # implemented by sub-classes

  protected :initialize_available_filters

  # Adds an available filter

    @available_filters ||= ActiveSupport::OrderedHash.new

    @available_filters[field] = options

    @available_filters

  # Removes an available filter

  def delete_available_filter(field)

    if @available_filters

      @available_filters.delete(field)

  # Return a hash of available filters

  def available_filters

  # Returns a Hash of columns and the key for sorting

  def sortable_columns

    available_columns.inject({}) {|h, column|

    }

  end

  def block_columns

    columns.reject(&:inline?)

  def available_inline_columns

    available_columns.select(&:inline?)

      next unless v and !v.empty?

      operator = operator_for(field)

      if %w(assigned_to_id author_id user_id watcher_id).include?(field)

        if v.delete("me")

          if User.current.logged?

      customized_key = "#{assoc}_id"

      customized_class = queried_class.reflect_on_association(assoc.to_sym).klass.base_class rescue nil

      raise "Unknown #{queried_class.name} association #{assoc}" unless customized_class

    where = sql_for_field(field, operator, value, db_table, db_field, true)

    if operator =~ /[<>]/

      where = "(#{where}) AND #{db_table}.#{db_field} <> ''"

    if assoc.present?

      filter_id = "#{assoc}.#{filter_id}"

      filter_name = l("label_attribute_of_#{assoc}", :name => filter_name)

    add_available_filter filter_id, options.merge({

      :name => filter_name,

      :field => field

    })

  # Adds filters for the given custom fields scope

  def add_custom_fields_filters(scope, assoc=nil)

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

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

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

    QueryColumn.new(:relations, :caption => :label_related_issues),

    QueryColumn.new(:description, :inline => false)

  ]

    end

    principals.uniq!

    principals.sort!

    users = principals.select {|p| p.is_a?(User)}

    add_available_filter "status_id",

      :type => :list_optional, :values => assigned_to_values

    ) unless assigned_to_values.empty?

    add_available_filter("member_of_group",

      :type => :list_optional, :values => group_values

    ) unless group_values.empty?

    add_available_filter "due_date", :type => :date

    add_available_filter "estimated_hours", :type => :float

    add_available_filter "done_ratio", :type => :integer

    if User.current.allowed_to?(:set_issues_private, nil, :global => true) ||

      User.current.allowed_to?(:set_own_issues_private, nil, :global => true)

  rescue ::ActiveRecord::StatementInvalid => e

    raise StatementInvalid.new(e.message)

  end

  # Returns the issue count by group or nil if query is not grouped

  def issue_count_by_group

    r = nil

  rescue ::ActiveRecord::StatementInvalid => e

    raise StatementInvalid.new(e.message)

  end

  # Returns the issues

  # Valid options are :order, :offset, :limit, :include, :conditions

  def issues(options={})

  def sql_for_member_of_group_field(field, operator, value)

    if operator == '*' # Any group

      operator = '=' # Override the operator since we want to find by assigned_to

    elsif operator == "!*"

      operator = '!' # Override the operator since we want to find by assigned_to

    else

      groups = Group.where(:id => value).all

  has_many :visible_journals,

    :class_name => 'Journal',

    :as => :journalized,

      ["(#{Journal.table_name}.private_notes = ? OR (#{Project.allowed_to_condition(User.current, :view_private_notes)}))", false]

    },

    :readonly => true

  before_create :default_assign

  before_save :close_duplicates, :update_done_ratio_from_issue_status,

              :force_updated_on_change, :update_closed_on, :set_assigned_to_was

  after_save :reschedule_following_issues, :update_nested_set_attributes,

             :update_parent_attributes, :create_journal

  # Should be after_create but would be called before previous after_save callbacks

        end

      else

        "(#{table_name}.is_private = #{connection.quoted_false})"

    end

  end

  # Returns true if usr or current user is allowed to view the issue

  def visible?(usr=nil)

        end

      else

        !self.is_private?

    end

  end

  # Returns true if user or current user is allowed to edit or add a note to the issue

  def editable?(user=User.current)

    @workflow_rule_by_attribute = nil

    @assignable_versions = nil

    @relations = nil

    base_reload(*args)

  end

    self.status = issue.status

    self.author = User.current

    unless options[:attachments] == false

        attachement.copy(:container => self)

      end

    end

    write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h)

  end

  safe_attributes 'project_id',

    :if => lambda {|issue, user|

      if issue.new_record?

    :if => lambda {|issue, user| user.allowed_to?(:add_issue_notes, issue.project)}

  safe_attributes 'private_notes',

  safe_attributes 'watcher_user_ids',

  safe_attributes 'is_private',

    :if => lambda {|issue, user|

      s = attrs['parent_issue_id'].to_s

      unless (m = s.match(%r{\A#?(\d+)\z})) && (m[1] == parent_id.to_s || Issue.visible(user).exists?(m[1]))

        @invalid_parent_issue_id = attrs.delete('parent_issue_id')

    end

    if attrs['custom_field_values'].present?

      editable_custom_field_ids = editable_custom_field_values(user).map {|v| v.custom_field_id.to_s}

    return {} if roles.empty?

    result = {}

    if workflow_permissions.any?

      workflow_rules = workflow_permissions.inject({}) do |h, wp|

        h[wp.field_name] ||= {}

  private :workflow_rule_by_attribute

  def done_ratio

      status.default_done_ratio

    else

      read_attribute(:done_ratio)

          errors.add :base, v.custom_field.name + ' ' + l('activerecord.errors.messages.blank')

        end

      else

          errors.add attribute, :blank

        end

      end

  # Set the done_ratio using the status if that setting is set.  This will keep the done_ratios

  # even if the user turns off the setting later

  def update_done_ratio_from_issue_status

      self.done_ratio = status.default_done_ratio

    end

  end

      elsif project_id_changed?

        if project.shared_versions.include?(fixed_version)

          versions << fixed_version

      else

        versions << fixed_version

      end

    !relations_to.detect {|ir| ir.relation_type == 'blocks' && !ir.issue_from.closed?}.nil?

  end

  # Returns an array of statuses that user is able to apply

  def new_statuses_allowed_to(user=User.current, include_default=false)

    if new_record? && @copied_from

      initial_status ||= status

      initial_assigned_to_id = assigned_to_id_changed? ? assigned_to_id_was : assigned_to_id

        (user.id == initial_assigned_to_id || user.group_ids.include?(initial_assigned_to_id))

      statuses = initial_status.find_new_statuses_allowed_to(

          elsif (issue_status[child] == ePROCESS_RELATIONS_ONLY)

            queue << child

            issue_status[child] = ePROCESS_ALL

        end

      end

          # or if it starts before the given date

          if start_date == leaf.start_date || date > leaf.start_date

            leaf.reschedule_on!(date)

        else

          leaf.reschedule_on!(date)

    end

  end

  def <=>(issue)

    if issue.nil?

  def self.update_versions_from_hierarchy_change(project)

    moved_project_ids = project.self_and_descendants.reload.collect(&:id)

    # Update issues of the moved projects and issues assigned to a version of a moved project

  end

  def parent_issue_id=(arg)

    s = arg.to_s.strip.presence

    if s && (m = s.match(%r{\A#?(\d+)\z})) && (@parent_issue = Issue.find_by_id(m[1]))

      @invalid_parent_issue_id = nil

    elsif s.blank?

      @parent_issue = nil

    end

  end

  def self.cross_project_scope(project, scope=nil)

    if project.nil?

      return Issue

    end

  end

  # Extracted from the ReportsController.

  def self.by_tracker(project)

    count_and_group_by(:project => project,

  end

  def self.by_subproject(project)

                                                #{Issue.table_name}.project_id as project_id,

                                                #{Issue.table_name}, #{Project.table_name}, #{IssueStatus.table_name} s

                                                #{Issue.table_name}.status_id=s.id

                                                and #{Issue.table_name}.project_id = #{Project.table_name}.id

                                                and #{visible_condition(User.current, :project => project, :with_subprojects => true)}

    if root_id.nil?

      # issue was just created

      self.root_id = (@parent_issue.nil? ? id : @parent_issue.root_id)

      if @parent_issue

        move_to_child_of(@parent_issue)

      end

        move_to_right_of(root)

      end

      old_root_id = root_id

      if @parent_issue

        move_to_child_of(@parent_issue)

      end

      if p.start_date && p.due_date && p.due_date < p.start_date

        p.start_date, p.due_date = p.due_date, p.start_date

      end

      # done ratio = weighted average ratio of leaves

      unless Issue.use_status_for_done_ratio? && p.status && p.status.default_done_ratio

        leaves_count = p.leaves.count

          if average == 0

            average = 1

          end

        end

      end

      p.estimated_hours = p.leaves.sum(:estimated_hours).to_f

      p.estimated_hours = nil if p.estimated_hours == 0.0

      # ancestors will be recursively updated

      p.save(:validate => false)

    end

  def close_duplicates

    if closing?

      duplicates.each do |duplicate|

        duplicate.reload

        # Don't re-close it if it's already closed

        next if duplicate.closed?

      self.updated_on = current_time_from_proper_timezone

      if new_record?

        self.created_on = updated_on

    end

  end

  # Callback for setting closed_on when the issue is closed.

  # The closed_on attribute stores the time of the last closing

          before = @custom_values_before_change[c.custom_field_id]

          after = c.value

          next if before == after || (before.blank? && after.blank?)

          if before.is_a?(Array) || after.is_a?(Array)

            before = [before] unless before.is_a?(Array)

            after = [after] unless after.is_a?(Array)

            # values removed

            (before - after).reject(&:blank?).each do |value|

              @current_journal.details << JournalDetail.new(:property => 'cf',

    where = "#{Issue.table_name}.#{select_field}=j.id"

                                                j.id as #{select_field},

                                                  #{Issue.table_name}, #{Project.table_name}, #{IssueStatus.table_name} s, #{joins} j

                                                and #{where}

                                                and #{Issue.table_name}.project_id=#{Project.table_name}.id

                                                and #{visible_condition(User.current, :project => project)}

                                              group by s.id, s.is_closed, j.id")

  end

end

                              :order => sort_clause,

                              :offset => @offset,

                              :limit => @limit)

      @issue_count_by_group = @query.issue_count_by_group

      respond_to do |format|

        format.html { render :template => 'issues/index', :layout => !request.xhr? }

    call_hook(:controller_issues_new_before_save, { :params => params, :issue => @issue })

    @issue.save_attachments(params[:attachments] || (params[:issue] && params[:issue][:uploads]))

    if @issue.save

      call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})

      respond_to do |format|

        format.html {

    end

    if saved

      render_attachment_warning_if_needed(@issue)

      flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?

<%= form_tag({}) do -%>

<%= hidden_field_tag 'back_url', url_for(params), :id => nil %>

<div class="autoscroll">

  <thead>

    <tr>

      <th class="checkbox hide-when-print">

        <%= link_to image_tag('toggle_check.png'), {},

                              :onclick => 'toggleIssuesSelection(this); return false;',

      <% query.inline_columns.each do |column| %>

    </tr>

  </thead>

  <tbody>

  <% issue_list(issues) do |issue, level| -%>

    <% reset_cycle %>

    <tr class="group open">

      <td colspan="<%= query.inline_columns.size + 2 %>">

        <span class="expander" onclick="toggleRowGroup(this);">&nbsp;</span>

      </td>

    </tr>

  <% end %>

  <tr id="issue-<%= issue.id %>" class="hascontextmenu <%= cycle('odd', 'even') %> <%= issue.css_classes %> <%= level > 0 ? "idnt idnt-#{level}" : nil %>">

    <td class="checkbox hide-when-print"><%= check_box_tag("ids[]", issue.id, false, :id => nil) %></td>

</table>

</div>

<% end -%>

  unless @issue.disabled_core_fields.include?('estimated_hours')

    unless @issue.estimated_hours.nil?

      rows.right l(:field_estimated_hours), l_hours(@issue.estimated_hours), :class => 'estimated-hours'

  end

  if User.current.allowed_to?(:view_time_entries, @project)

  end

end %>

<%= render_custom_fields_rows(@issue) %>

  field_assignable: Issues can be assigned to this role

  field_redirect_existing_links: Redirect existing links

  field_estimated_hours: Estimated time

  field_column_names: Columns

  field_time_entries: Log time

  field_time_zone: Time zone