Redmine

  # 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

      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

    json = {}

    available_filters.each do |field, filter|

      options = {:type => filter[:type], :name => filter[:name]}

      options[:remote] = true if filter.remote

      if has_filter?(field) || !filter.remote

  end

  def sql_for_custom_field(field, operator, value, custom_field_id)

    filter = @available_filters[field]

    return nil unless filter

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

    filter = available_filters[field]

    target_class = filter[:through].format.target_class

    "#{queried_table_name}.id #{not_in} IN (" +

      "SELECT customized_id FROM #{CustomValue.table_name}" +

      " WHERE customized_type='#{queried_class}' AND custom_field_id=#{custom_field_id}" +

      "  SELECT customized_id FROM #{CustomValue.table_name}" +

      "  WHERE customized_type='#{target_class}' AND custom_field_id=#{chained_custom_field_id}" +

  end

    filter = available_filters[field]

    target_table_name = filter[:field].format.target_class.table_name

    "#{queried_table_name}.id #{not_in} IN (" +

      "SELECT customized_id FROM #{CustomValue.table_name}" +

      " WHERE customized_type='#{queried_class}' AND custom_field_id=#{custom_field_id}" +

      "  SELECT id FROM #{target_table_name} WHERE #{sql_for_field(field, operator, value, filter[:field].format.target_class.table_name, attribute)}))"

  end

	# Sort by first role and principal

  scope :sorted, lambda {

    includes(:member_roles, :roles, :principal).

      order(Principal.fields_for_order_statement)

  }

  scope :sorted_by_project, lambda {

  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'

      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

    return entries, days

    super

    if position_changed?

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

          where parent_id = parent.id), 1)"

      )

    end

  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

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

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

        join_alias(custom_field) + "_" + custom_field.field_format

      end

      protected :value_join_alias

    end

    class EnumerationFormat < RecordList

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

  ]

          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

  def destroy

    @project_to_destroy = @project

    if api_request? || params[:confirm]

      respond_to do |format|

        format.html { redirect_to admin_projects_path }

        format.api  { render_api_ok }

            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

  def self.fields_for_order_statement(table=nil)

    table ||= table_name

    columns.uniq.map {|field| "#{table}.#{field}"}

  end

  def logout_user

    if User.current.logged?

      cookies.delete(autologin_cookie_name)

      self.logged_user = nil

    end

  end

                    search_scope(user, projects, options).

                    joins(:custom_values).

                    where(visibility).

                    options[:limit]

                  )

                  queries += 1

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

          cattr_accessor :customizable_options

          self.customizable_options = options

                                   :as => :customized,

                                   :inverse_of => :customized,

                                   :dependent => :delete_all,

  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'