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

  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

  # 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

          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

module OpenIdAuthentication

  class Association < ActiveRecord::Base

    def from_record

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

        (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

  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?