Redmine

    respond_to do |format|

      format.html {

        @trackers = @project.trackers.sorted.to_a

        @with_subprojects = params[:with_subprojects].nil? ? Setting.display_subprojects_issues? : (params[:with_subprojects] == '1')

        project_ids = @with_subprojects ? @project.self_and_descendants.collect(&:id) : [@project.id]

        @issues_by_version = {}

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

          issues = Issue.visible.

          @issues_by_version = issues.group_by(&:fixed_version)

        end

      }

      format.api {

        @versions = @project.shared_versions.to_a

    respond_to do |format|

      format.html {

        @issues = @version.fixed_issues.visible.

      }

      format.api

    end

      else

        respond_to do |format|

          format.html { render :action => 'new' }

        end

      end

    end

            flash[:notice] = l(:notice_successful_update)

            redirect_back_or_default settings_project_path(@project, :tab => 'versions')

          }

        end

      else

        respond_to do |format|

          format.html { render :action => 'edit' }

        end

      end

    end

      @version.destroy

      respond_to do |format|

        format.html { redirect_back_or_default settings_project_path(@project, :tab => 'versions') }

      end

    else

      respond_to do |format|

          flash[:error] = l(:notice_unable_delete_version)

          redirect_to settings_project_path(@project, :tab => 'versions')

        }

      end

    end

  end

    if ids = params[:tracker_ids]

      @selected_tracker_ids = (ids.is_a? Array) ? ids.collect { |id| id.to_i.to_s } : ids.split('/').collect { |id| id.to_i.to_s }

    else

    end

  end

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

class Enumeration < ActiveRecord::Base

  include Redmine::SubclassFactory

  belongs_to :project

  acts_as_tree

  before_destroy :check_integrity

  attr_protected :type

  scope :sorted, lambda { order(:position) }

  scope :active, lambda { where(:active => true) }

  scope :system, lambda { where(:project_id => nil) }

  def self.default

    # Creates a fake default scope so Enumeration.default will check

    position <=> enumeration.position

  end

  # Returns the Subclasses of Enumeration.  Each Subclass needs to be

  # required in development mode.

  # Does the +new+ Hash override the previous Enumeration?

  def self.overriding_change?(new, previous)

      return false

    else

      return true

  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),

  attr_protected :id

  scope :sorted, lambda { order(:position) }

  safe_attributes 'name',

  # Update all the +Issues+ setting their done_ratio to the value of their +IssueStatus+

  def self.update_issue_done_ratios

  def new_statuses_allowed_to(roles, tracker, author=false, assignee=false)

    self.class.new_statuses_allowed(self, roles, tracker, author, assignee)

  end

  alias :find_new_statuses_allowed_to :new_statuses_allowed_to

  def self.new_statuses_allowed(status, roles, tracker, author=false, assignee=false)

      status_id = status.try(:id) || 0

      scope = IssueStatus.

      unless author && assignee

        if author || assignee

    position <=> status.position

  end

  private

    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

            unless options[:attachments] == 'only'

              r = fetch_ranks_and_ids(

              )

              queries += 1

              if !options[:titles_only] && searchable_options[:search_custom_fields]

                searchable_custom_fields = CustomField.where(:type => "#{self.name}CustomField", :searchable => true).to_a

                if searchable_custom_fields.any?

                    field.visibility_by_project_condition(searchable_options[:project_key], user, "#{CustomValue.table_name}.custom_field_id")

                  }

                  clauses = []

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

                  end

                  visibility = clauses.join(' OR ')

                  r |= fetch_ranks_and_ids(

                  )

                  queries += 1

                end

              if !options[:titles_only] && searchable_options[:search_journals]

                r |= fetch_ranks_and_ids(

                )

                queries += 1

              end

            if searchable_options[:search_attachments] && (options[:titles_only] ? options[:attachments] == 'only' : options[:attachments] != '0')

              r |= fetch_ranks_and_ids(

              )

              queries += 1

            end

          end

          def search_tokens_condition(columns, tokens, all_words)

            sql = (['(' + token_clauses.join(' OR ') + ')'] * tokens.size).join(all_words ? ' AND ' : ' OR ')

          end

          private :search_tokens_condition

          def search_token_match_statement(column, value='?')

            Redmine::Database.like(column, value)

          end

          private :search_token_match_statement

          def fetch_ranks_and_ids(scope, limit)

            scope.

          end

          private :fetch_ranks_and_ids

          # Returns the search scope for user and projects

            end

            scope

          end

          private :search_scope

          # Returns search results of given ids

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