Redmine

  attr_accessor :name, :sortable, :groupable, :default_order

  include Redmine::I18n

    self.groupable = options[:groupable] || false

  # Returns true if the column is sortable, otherwise false

  def sortable?

    !sortable.nil?

  end

    self.sortable = custom_field.order_statement || false

  serialize :sort_criteria, Array

                  ">="  => :label_greater_or_equal,

                  "<="  => :label_less_or_equal,

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

    QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position", :groupable => true),

    QueryColumn.new(:status, :sortable => "#{IssueStatus.table_name}.position", :groupable => true),

    QueryColumn.new(:priority, :sortable => "#{Enumeration.table_name}.position", :default_order => 'desc', :groupable => true),

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

    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(:done_ratio, :sortable => "#{Issue.table_name}.done_ratio", :groupable => true),

      errors.add label_for(field), :blank unless 

    if User.current.logged?

      @available_filters["watcher_id"] = { :type => :list, :order => 15, :values => [["<< #{l(:label_me)} >>", "me"]] }

    end

      unless @project.descendants.active.empty?

        @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.descendants.visible.collect{|s| [s.name, s.id.to_s] } }

                            IssueCustomField.find(:all)

  # Returns an array of columns that can be used to group the results

  def groupable_columns

    available_columns.select {|c| c.groupable}

  end

  def sort_criteria=(arg)

    c = []

    if arg.is_a?(Hash)

      arg = arg.keys.sort.collect {|k| arg[k]}

    end

    c = arg.select {|k,o| !k.to_s.blank?}.slice(0,3).collect {|k,o| [k.to_s, o == 'desc' ? o : 'asc']}

    write_attribute(:sort_criteria, c)

  end

  def sort_criteria

    read_attribute(:sort_criteria) || []

  end

  def sort_criteria_key(arg)

    sort_criteria && sort_criteria[arg] && sort_criteria[arg].first

  end

  def sort_criteria_order(arg)

    sort_criteria && sort_criteria[arg] && sort_criteria[arg].last

  end

  # Returns the SQL sort order that should be prepended for grouping

  def group_by_sort_order

    if grouped? && (column = group_by_column)

      column.sortable.is_a?(Array) ?

        column.sortable.collect {|s| "#{s} #{column.default_order}"}.join(',') :

        "#{column.sortable} #{column.default_order}"

    end

  end

  # Returns true if the query is a grouped query

  def grouped?

    !group_by.blank?

  end

  def group_by_column

    groupable_columns.detect {|c| c.name.to_s == group_by}

  end

    if project && !@project.descendants.active.empty?

          ids += project.descendants.collect(&:id)

        ids += project.descendants.collect(&:id)

    project_clauses <<  Project.allowed_to_condition(User.current, :view_issues)

      operator = operator_for(field)

      # "me" value subsitution

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

        v.push(User.current.logged? ? User.current.id.to_s : "0") if v.delete("me")

      end

        sql << sql_for_field(field, operator, v, db_table, db_field, true) + ')'

      elsif field == 'watcher_id'

        db_table = Watcher.table_name

        db_field = 'user_id'

        sql << "#{Issue.table_name}.id #{ operator == '=' ? 'IN' : 'NOT IN' } (SELECT #{db_table}.watchable_id FROM #{db_table} WHERE #{db_table}.watchable_type='Issue' AND "

        sql << sql_for_field(field, '=', v, db_table, db_field) + ')'

        sql << '(' + sql_for_field(field, operator, v, db_table, db_field) + ')'

      filters_clauses << sql

  # Helper method to generate the WHERE sql for a +field+, +operator+ and a +value+

  def sql_for_field(field, operator, value, db_table, db_field, is_custom_filter=false)

    case operator