comparison app/models/project.rb @ 1517:dffacf8a6908 redmine-2.5

Update to Redmine SVN revision 13367 on 2.5-stable branch

   has_many :enabled_modules, :dependent => :delete_all
   has_and_belongs_to_many :trackers, :order => "#{Tracker.table_name}.position"
   has_many :issues, :dependent => :destroy, :include => [:status, :tracker]
   has_many :issue_changes, :through => :issues, :source => :journals
   has_many :versions, :dependent => :destroy, :order => "#{Version.table_name}.effective_date DESC, #{Version.table_name}.name DESC"
-  has_many :time_entries, :dependent => :delete_all
+  has_many :time_entries, :dependent => :destroy
   has_many :queries, :class_name => 'IssueQuery', :dependent => :delete_all
   has_many :documents, :dependent => :destroy
   has_many :news, :dependent => :destroy, :include => :author
   has_many :issue_categories, :dependent => :delete_all, :order => "#{IssueCategory.table_name}.name"
   has_many :boards, :dependent => :destroy, :order => "position ASC"

                           :class_name => 'IssueCustomField',
                           :order => "#{CustomField.table_name}.position",
                           :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}",
                           :association_foreign_key => 'custom_field_id'
 
-  acts_as_nested_set :order => 'name', :dependent => :destroy
+  acts_as_nested_set :dependent => :destroy
   acts_as_attachable :view_permission => :view_files,
                      :delete_permission => :manage_files
 
   acts_as_customizable
   acts_as_searchable :columns => ['name', 'identifier', 'description'], :project_key => 'id', :permission => nil

   #
   # This will raise a ActiveRecord::Rollback if the TimeEntryActivity
   # does not successfully save.
   def create_time_entry_activity_if_needed(activity)
     if activity['parent_id']
-
       parent_activity = TimeEntryActivity.find(activity['parent_id'])
       activity['name'] = parent_activity.name
       activity['position'] = parent_activity.position
-
       if Enumeration.overridding_change?(activity, parent_activity)
         project_activity = self.time_entry_activities.create(activity)
-
         if project_activity.new_record?
           raise ActiveRecord::Rollback, "Overridding TimeEntryActivity was not successfully saved"
         else
-          self.time_entries.update_all("activity_id = #{project_activity.id}", ["activity_id = ?", parent_activity.id])
+          self.time_entries.
+            where(["activity_id = ?", parent_activity.id]).
+            update_all("activity_id = #{project_activity.id}")
         end
       end
     end
   end
 

   # Used in BuildProjectsTree migration
   def self.rebuild_tree!
     transaction do
       update_all "lft = NULL, rgt = NULL"
       rebuild!(false)
+      all.each { |p| p.set_or_update_position_under(p.parent) }
     end
   end
 
   # Returns an array of the trackers used by the project and its active sub projects
   def rolled_up_trackers

   end
 
   # Closes open and locked project versions that are completed
   def close_completed_versions
     Version.transaction do
-      versions.where(:status => %w(open locked)).all.each do |version|
+      versions.where(:status => %w(open locked)).each do |version|
         if version.completed?
           version.update_attribute(:status, 'closed')
         end
       end
     end

     end
   end
 
   # Returns a hash of project users grouped by role
   def users_by_role
-    members.includes(:user, :roles).all.inject({}) do |h, m|
+    members.includes(:user, :roles).inject({}) do |h, m|
       m.roles.each do |r|
         h[r] ||= []
         h[r] << m.user
       end
       h

     else
       allowed_permissions.include? action
     end
   end
 
-  def module_enabled?(module_name)
-    module_name = module_name.to_s
-    enabled_modules.detect {|m| m.name == module_name}
+  # Return the enabled module with the given name
+  # or nil if the module is not enabled for the project
+  def enabled_module(name)
+    name = name.to_s
+    enabled_modules.detect {|m| m.name == name}
+  end
+
+  # Return true if the module with the given name is enabled
+  def module_enabled?(name)
+    enabled_module(name).present?
   end
 
   def enabled_module_names=(module_names)
     if module_names && module_names.is_a?(Array)
       module_names = module_names.collect(&:to_s).reject(&:blank?)

       version.update_attribute :status, 'open'
     end
 
     # Get issues sorted by root_id, lft so that parent issues
     # get copied before their children
-    project.issues.reorder('root_id, lft').all.each do |issue|
+    project.issues.reorder('root_id, lft').each do |issue|
       new_issue = Issue.new
       new_issue.copy_from(issue, :subtasks => false, :link => false)
       new_issue.project = self
       # Changing project resets the custom field values
       # TODO: handle this in Issue#project=

     end
   end
 
   # Returns the systemwide active activities merged with the project specific overrides
   def system_activities_and_project_overrides(include_inactive=false)
-    if include_inactive
-      return TimeEntryActivity.shared.
-        where("id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)).all +
-        self.time_entry_activities
-    else
-      return TimeEntryActivity.shared.active.
-        where("id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)).all +
-        self.time_entry_activities.active
-    end
+    t = TimeEntryActivity.table_name
+    scope = TimeEntryActivity.where(
+      "(#{t}.project_id IS NULL AND #{t}.id NOT IN (?)) OR (#{t}.project_id = ?)",
+      time_entry_activities.map(&:parent_id), id
+    )
+    unless include_inactive
+      scope = scope.active
+    end
+    scope
   end
 
   # Archives subprojects recursively
   def archive!
     children.each do |subproject|

   end
 
   def update_position_under_parent
     set_or_update_position_under(parent)
   end
+
+  public
 
   # Inserts/moves the project so that target's children or root projects stay alphabetically sorted
   def set_or_update_position_under(target_parent)
     parent_was = parent
     sibs = (target_parent.nil? ? self.class.roots : target_parent.children)