Redmine

  def setup

    @project = Project.find(1)

  end

  def test_activity_without_subprojects

    events = find_events(User.anonymous, :project => @project)

    assert_not_nil events

      module ClassMethods

        # Options:

        # * :columns - a column or an array of columns to search

        # * :project_key - project foreign key (default to project_id)

        # * :date_column - name of the datetime column (default to created_on)

        # * :permission - permission required to search the model (default to :view_"objects")

        def acts_as_searchable(options = {})

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

          cattr_accessor :searchable_options

          if searchable_options[:columns].nil?

            raise 'No searchable column defined.'

          searchable_options[:project_key] ||= "#{table_name}.project_id"

          searchable_options[:date_column] ||= "#{table_name}.created_on"

          searchable_options[:order_column] ||= searchable_options[:date_column]

          # Permission needed to search this model

          searchable_options[:permission] = "view_#{self.name.underscore.pluralize}".to_sym unless searchable_options.has_key?(:permission)

          # Should we search custom fields on this model ?

          searchable_options[:search_custom_fields] = !reflect_on_association(:custom_values).nil?

          send :include, Redmine::Acts::Searchable::InstanceMethods

        end

      end

          base.extend ClassMethods

        end

        module ClassMethods

          # Searches the model for the given tokens

          # projects argument can be either nil (will search all projects), a project or an array of projects

                token_clauses << custom_field_sql

              end

            end

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

            find_options[:conditions] = [sql, * (tokens.collect {|w| "%#{w.downcase}%"} * token_clauses.size).sort]

            project_conditions = []

            project_conditions << (searchable_options[:permission].nil? ? Project.visible_by(User.current) :

                                                 Project.allowed_to_condition(User.current, searchable_options[:permission]))

            project_conditions << "#{searchable_options[:project_key]} IN (#{projects.collect(&:id).join(',')})" unless projects.nil?

            results = []

            results_count = 0

            with_scope(:find => {:conditions => project_conditions.join(' AND ')}) do

              with_scope(:find => find_options) do

                results_count = count(:all)

                     :delete_permission => :manage_files

  acts_as_customizable

  acts_as_event :title => Proc.new {|o| "#{l(:label_project)}: #{o.name}"},

                :url => Proc.new {|o| {:controller => 'projects', :action => 'show', :id => o}},

                :author => nil

class Issue < ActiveRecord::Base

  include Redmine::SafeAttributes

  belongs_to :project

  belongs_to :tracker

  belongs_to :status, :class_name => 'IssueStatus', :foreign_key => 'status_id'

  acts_as_attachable :after_remove => :attachment_removed

  acts_as_customizable

  acts_as_watchable

                     :include => [:project, :journals],

                     # sort by id so that limited eager loading doesn't break with postgresql

                     :order_column => "#{table_name}.id"

                :url => Proc.new {|o| {:controller => 'issues', :action => 'show', :id => o.id}},

                :type => Proc.new {|o| 'issue' + (o.closed? ? ' closed' : '') }

    }

  }

  before_create :default_assign

  before_save :close_duplicates, :update_done_ratio_from_issue_status

  after_save :reschedule_following_issues, :update_nested_set_attributes, :update_parent_attributes, :create_journal

  after_destroy :update_parent_attributes

  # Returns true if usr or current user is allowed to view the issue

  def visible?(usr=nil)

    (usr || User.current).allowed_to?(:view_issues, self.project)

  belongs_to :category, :class_name => "DocumentCategory", :foreign_key => "category_id"

  acts_as_attachable :delete_permission => :manage_documents

  acts_as_event :title => Proc.new {|o| "#{l(:label_document)}: #{o.title}"},

                :author => Proc.new {|o| (a = o.attachments.find(:first, :order => "#{Attachment.table_name}.created_on ASC")) ? a.author : nil },

                :url => Proc.new {|o| {:controller => 'documents', :action => 'show', :id => o.id}}

    c = details.detect {|detail| detail.prop_key == 'status_id'}

    (c && c.value) ? IssueStatus.find_by_id(c.value.to_i) : nil

  end

  def new_value_for(prop)

    c = details.detect {|detail| detail.prop_key == prop}

    c ? c.value : nil

  has_many :changes, :dependent => :delete_all

  has_and_belongs_to_many :issues

  acts_as_event :title => Proc.new {|o| "#{l(:label_revision)} #{o.format_identifier}" + (o.short_comments.blank? ? '' : (': ' + o.short_comments))},

                :description => :long_comments,

                :datetime => :committed_on,

                :url => Proc.new {|o| {:controller => 'repositories', :action => 'revision', :id => o.repository.project, :rev => o.identifier}}

  acts_as_activity_provider :timestamp => "#{table_name}.committed_on",

                            :author_key => :user_id,

  validates_length_of :title, :maximum => 60

  validates_length_of :summary, :maximum => 255

  acts_as_event :url => Proc.new {|o| {:controller => 'news', :action => 'show', :id => o.id}}

  acts_as_activity_provider :find_options => {:include => [:project, :author]},

                            :author_key => :author_id

  acts_as_attachable

  belongs_to :last_reply, :class_name => 'Message', :foreign_key => 'last_reply_id'

                     :include => {:board => :project},

                     :project_key => 'project_id',

                     :date_column => "#{table_name}.created_on"

  acts_as_tree :dependent => :nullify, :order => 'title'

  acts_as_watchable

                     :include => [{:wiki => :project}, :content],

                     :project_key => "#{Wiki.table_name}.project_id"

  attr_accessor :redirect_existing_links

  validates_presence_of :title

    <h3><%= l(:label_result_plural) %> (<%= @results_by_type.values.sum %>)</h3>

    <dl id="search-results">

      <% end %>

    </dl>

<% end %>

        @results += r

        @results_by_type[s] += c

      end

      if params[:previous].nil?

        if @results.size > limit

          @results = @results[0, limit]

        end

      else

        if @results.size > limit

          @results = @results[-(limit), limit]

        end

      end

  value: "This word was and an other was added"

  prop_key: description

  journal_id: 3

  lft: 1

  rgt: 2

issues_008: 

  project_id: 1

  updated_on: <%= 10.days.ago.to_date.to_s(:db) %>

  priority_id: 5

  journalized_type: Issue

  user_id: 1

  journalized_id: 6