Redmine

    if User.current.logged?

      cookies.delete(autologin_cookie_name)

      Token.where(["user_id = ? AND action = ?", User.current.id, 'autologin']).delete_all

      self.logged_user = nil

    end

  end

            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

        @versions.reject! {|version| !project_ids.include?(version.project_id) && @issues_by_version[version].blank?}

        @issues = @version.fixed_issues.visible.

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

          preload(:project).

          to_a

      }

      format.api

      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

  # to move in project_custom_field

  def self.for_all

  end

  def type_name

class Enumeration < ActiveRecord::Base

  include Redmine::SubclassFactory

  belongs_to :project

    super

    if position_changed?

      self.class.where.not(:parent_id => nil).update_all(

          where parent_id = parent.id), 1)"

      )

    end

      if p.priority_derived?

        # priority = highest priority of open children

        # priority is left unchanged if all children are closed and there's no default priority defined

          p.priority = IssuePriority.find_by_position(priority_position)

        elsif default_priority = IssuePriority.default

          p.priority = default_priority

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

      subselect = "SELECT MAX(j.created_on) FROM #{Journal.table_name} j" +

        " JOIN #{JournalDetail.table_name} d ON d.journal_id = j.id" +

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

      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

    s = []

    if from

      if from.is_a?(Date)

      else

        from = from - 1 # second

      end

    end

    if to

      if to.is_a?(Date)

      end

      if self.class.default_timezone == :utc

        to = to.utc

  # 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|

      end

      hash[mapped_name] ||= { :commits_count => 0, :changes_count => 0 }

      if element.is_a?(Changeset)

      else

      end

      hash

    end

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

      where(["property = 'attr' AND prop_key = 'assigned_to_id' AND old_value = ?", id.to_s]).

      update_all(['old_value = ?', substitute.id.to_s])

    JournalDetail.

    Message.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.id])

    News.where(['author_id = ?', id]).update_all(['author_id = ?', substitute.id])

    # Remove private queries and keep public ones

    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

    Enumeration.all.group_by(&:opt).each do |opt, enums|

      enums.each_with_index do |enum, i|

        # do not call model callbacks

      end

    end

  end

    CustomField.all.group_by(&:type).each  do |t, fields|

      fields.each_with_index do |field, i|

        # do not call model callbacks

      end

    end

  end

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

  def down

    add_column :issue_statuses, :is_default, :boolean, :null => false, :default => false

    # Restores the first status as default

    IssueStatus.where(:id => default_status_id).update_all(:is_default => true)

  end

end

          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

                    search_scope(user, projects, options).

                    joins(:custom_values).

                    where(visibility).

                    options[:limit]

                  )

                  queries += 1

module OpenIdAuthentication

  class Association < ActiveRecord::Base

    def from_record

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

          end

        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

  def is_binary_data?

    ( self.count( "^ -~", "^\r\n" ).fdiv(self.size) > 0.3 || self.index( "\x00" ) ) unless empty?

  end

end

        (ActiveRecord::Base.connection.adapter_name =~ /mysql/i).present?

      end

      # Returns a SQL statement for case/accent (if possible) insensitive match

      def like(left, right, options={})

        neg = (options[:match] == false ? 'NOT ' : '')

      # 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

    query = IssueQuery.new(:project => Project.find(1), :name => '_')

    query.add_filter('fixed_version_id', '!*', [''])

    query.add_filter('cf_1', '!*', [''])

    assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NULL")

    find_issues_with_query(query)

  end

    query = IssueQuery.new(:project => Project.find(1), :name => '_')

    query.add_filter('fixed_version_id', '*', [''])

    query.add_filter('cf_1', '*', [''])

    assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NOT NULL")

    find_issues_with_query(query)

  end

  end

  def test_own_account_deletable_should_be_false_for_a_single_admin

    with_settings :unsubscribe => '1' do

      assert_equal false, User.find(1).own_account_deletable?

    @generated_tracker_name.succ!

    tracker = Tracker.new(attributes)

    tracker.name = @generated_tracker_name.dup if tracker.name.blank?

    yield tracker if block_given?

    tracker

  end