Redmine

        @issues_by_version = {}

        if @selected_tracker_ids.any? && @versions.any?

          issues = Issue.visible.

           includes(:project, :tracker).

           preload(:status, :priority, :fixed_version).

           where(:tracker_id => @selected_tracker_ids, :project_id => project_ids, :fixed_version_id => @versions.map(&:id)).

          @issues_by_version = issues.group_by(&:fixed_version)

        end

    respond_to do |format|

      format.html {

        @issues = @version.fixed_issues.visible.

         includes(:status, :tracker, :priority).

         preload(:project).

         to_a

      }

      format.api

    end

      limit(10).

      includes(:status, :project, :tracker, :priority).

      references(:status, :project, :tracker, :priority).

  end

  def issuesreportedbyme_items

      joins(:activity, :project).

      references(:issue => [:tracker, :status]).

      includes(:issue => [:tracker, :status]).

      to_a

  end

end

  def update_position

    super

    if position_changed?

    end

  end

    if issue_id && p = Issue.find_by_id(issue_id)

      if p.priority_derived?

        # priority = highest priority of open children

          p.priority = IssuePriority.find_by_position(priority_position)

        else

          p.priority = IssuePriority.default

  self.available_columns = [

    QueryColumn.new(:id, :sortable => "#{Issue.table_name}.id", :default_order => 'desc', :caption => '#', :frozen => true),

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

    QueryColumn.new(:parent, :sortable => ["#{Issue.table_name}.root_id", "#{Issue.table_name}.lft ASC"], :default_order => 'desc', :caption => :field_parent_issue),

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

    QueryColumn.new(:author, :sortable => lambda {User.fields_for_order_statement("authors")}, :groupable => true),

    QueryColumn.new(:assigned_to, :sortable => lambda {User.fields_for_order_statement}, :groupable => true),

    if is_closed_changed? && is_closed == true

      # First we update issues that have a journal for when the current status was set,

      # a subselect is used to update all issues with a single query

      Issue.where(:status_id => id, :closed_on => nil).

      # Then we update issues that don't have a journal which means the

      # current status was set on creation

  has_many :documents, :dependent => :destroy

  has_many :news, lambda {includes(:author)}, :dependent => :destroy

  has_many :issue_categories, lambda {order("#{IssueCategory.table_name}.name")}, :dependent => :delete_all

  has_one :repository, lambda {where(["is_default = ?", true])}

  has_many :repositories, :dependent => :destroy

  has_many :changesets, :through => :repository

  has_one :wiki, :dependent => :destroy

  # Custom field for the project issues

  has_and_belongs_to_many :issue_custom_fields,

                          :class_name => 'IssueCustomField',

                          :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}",

                          :association_foreign_key => 'custom_field_id'

  def sql_for_custom_field(field, operator, value, custom_field_id)

    db_table = CustomValue.table_name

    filter = @available_filters[field]

    return nil unless filter

    if filter[:field].format.target_class && filter[:field].format.target_class <= User

          int_values = value.first.to_s.scan(/[+-]?\d+/).map(&:to_i).join(",")

          if int_values.present?

            if is_custom_filter

            else

              sql = "#{db_table}.#{db_field} IN (#{int_values})"

            end

          end

        when :float

          if is_custom_filter

          else

            sql = "#{db_table}.#{db_field} BETWEEN #{value.first.to_f - 1e-5} AND #{value.first.to_f + 1e-5}"

          end

        sql = date_clause(db_table, db_field, parse_date(value.first), nil, is_custom_filter)

      else

        if is_custom_filter

        else

          sql = "#{db_table}.#{db_field} >= #{value.first.to_f}"

        end

        sql = date_clause(db_table, db_field, nil, parse_date(value.first), is_custom_filter)

      else

        if is_custom_filter

        else

          sql = "#{db_table}.#{db_field} <= #{value.first.to_f}"

        end

        sql = date_clause(db_table, db_field, parse_date(value[0]), parse_date(value[1]), is_custom_filter)

      else

        if is_custom_filter

        else

          sql = "#{db_table}.#{db_field} BETWEEN #{value[0].to_f} AND #{value[1].to_f}"

        end

  # Notes:

  # - this hash honnors the users mapping defined for the repository

  def stats_by_author

    #TODO: restore ordering ; this line probably never worked

    #commits.to_a.sort! {|x, y| x.last <=> y.last}

    user_ids = changesets.map(&:user_id).compact.uniq

    authors_names = User.where(:id => user_ids).inject({}) do |memo, user|

    QueryColumn.new(:spent_on, :sortable => ["#{TimeEntry.table_name}.spent_on", "#{TimeEntry.table_name}.created_on"], :default_order => 'desc', :groupable => true),

    QueryColumn.new(:tweek, :sortable => ["#{TimeEntry.table_name}.spent_on", "#{TimeEntry.table_name}.created_on"], :caption => l(:label_week)),

    QueryColumn.new(:user, :sortable => lambda {User.fields_for_order_statement}, :groupable => true),

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

    QueryColumn.new(:comments),

    QueryColumn.new(:hours, :sortable => "#{TimeEntry.table_name}.hours", :totalable => true),

  ]

  # Returns true if the user is allowed to delete the user's own account

  def own_account_deletable?

    Setting.unsubscribe? &&

  end

  safe_attributes 'firstname',

    end

    # indexes

    add_index "journal_details", ["journal_id"], :name => "journal_details_journal_id"

    Permission.create :controller => "issues", :action => "history", :description => "label_history", :sort => 1006, :is_public => true, :mail_option => 0, :mail_enabled => 0

class AddOpenIdAuthenticationTables < ActiveRecord::Migration

  def self.up

      t.integer :issued, :lifetime

      t.string :handle, :assoc_type

      t.binary :server_url, :secret

    end

      t.integer :timestamp, :null => false

      t.string :server_url, :null => true

      t.string :salt, :null => false

  end

  def self.down

  end

end

  def up

    say_with_time "Adding unique index on tokens, this may take some time..." do

      # Just in case

      Token.where(:value => duplicates).delete_all

      add_index :tokens, :value, :unique => true, :name => 'tokens_value'

        " AND #{Journal.table_name}.journalized_type = 'Issue' AND #{Journal.table_name}.journalized_id = #{Issue.table_name}.id" +

        " AND #{JournalDetail.table_name}.property = 'attr' AND #{JournalDetail.table_name}.prop_key = 'status_id'" +

        " AND #{JournalDetail.table_name}.old_value NOT IN (#{closed_status_values})" +

      Issue.update_all "closed_on = (#{subselect})"

      # Then set closed_on for closed issues that weren't up updated by the above UPDATE

          return if self.included_modules.include?(Redmine::Acts::Customizable::InstanceMethods)

          cattr_accessor :customizable_options

          self.customizable_options = options

                                   :as => :customized,

                                   :dependent => :delete_all,

                                   :validate => false

                    clauses << "(#{CustomValue.table_name}.custom_field_id IN (#{fields.map(&:id).join(',')}) AND (#{visibility}))"

                  end

                  visibility = clauses.join(' OR ')

                  r |= fetch_ranks_and_ids(

                    options[:limit]

                  )

                  queries += 1

                end

module OpenIdAuthentication

  class Association < ActiveRecord::Base

    def from_record

      OpenID::Association.new(handle, secret, issued, lifetime, assoc_type)

        end

        def insert_position

        end

        def remove_position

        end

        def position_scope_changed?

        def shift_positions

          offset = position_was <=> position

          min, max = [position, position_was].sort

          if r != max - min

            reset_positions_in_list

          end

      # Returns nil if the custom field can not be used for sorting.

      def order_statement(custom_field)

        # COALESCE is here to make sure that blank and NULL values are sorted equally

      end

      # Returns a GROUP BY clause that can used to group by custom value

          " AND #{alias_name}.customized_id = #{custom_field.class.customized_class.table_name}.id" +

          " AND #{alias_name}.custom_field_id = #{custom_field.id}" +

          " AND (#{custom_field.visibility_by_project_condition})" +

          " AND #{alias_name}.id = (SELECT max(#{alias_name}_2.id) FROM #{CustomValue.table_name} #{alias_name}_2" +

            " WHERE #{alias_name}_2.customized_type = #{alias_name}.customized_type" +

            " AND #{alias_name}_2.customized_id = #{alias_name}.customized_id" +

      def join_alias(custom_field)

        "cf_#{custom_field.id}"

      end

      protected :join_alias

    end

        # Make the database cast values into numeric

        # Postgresql will raise an error if a value can not be casted!

        # CustomValue validations should ensure that it doesn't occur

      end

      # Returns totals for the given scope

        scope.joins(:custom_values).

          where(:custom_values => {:custom_field_id => custom_field.id}).

          where.not(:custom_values => {:value => ''}).

      end

      def cast_total_value(custom_field, value)

      end

      def group_statement(custom_field)

      end

      def join_for_order_statement(custom_field)

          " AND #{alias_name}.customized_id = #{custom_field.class.customized_class.table_name}.id" +

          " AND #{alias_name}.custom_field_id = #{custom_field.id}" +

          " AND (#{custom_field.visibility_by_project_condition})" +

          " AND #{alias_name}.id = (SELECT max(#{alias_name}_2.id) FROM #{CustomValue.table_name} #{alias_name}_2" +

            " WHERE #{alias_name}_2.customized_type = #{alias_name}.customized_type" +

            " AND #{alias_name}_2.customized_id = #{alias_name}.customized_id" +

            " AND #{alias_name}_2.custom_field_id = #{alias_name}.custom_field_id)" +

          " LEFT OUTER JOIN #{target_class.table_name} #{value_join_alias custom_field}" +

      end

      def value_join_alias(custom_field)

      TRACKER_BUG = Tracker.find_by_position(1)

      TRACKER_FEATURE = Tracker.find_by_position(2)

      manager_role = roles[0]

      developer_role = roles[1]

      DEFAULT_ROLE = roles.last

                           'patch' =>TRACKER_FEATURE

                           }

        manager_role = roles[0]

        developer_role = roles[1]

        DEFAULT_ROLE = roles.last