joins_enabled_modules.patch - Redmine

             @issues_by_version = {}
             if @selected_tracker_ids.any? && @versions.any?
               issues = Issue.visible.
                 includes(:project, :tracker).
                 eager_load(:project, :tracker).
                 preload(:status, :priority, :fixed_version).
                 where(:tracker_id => @selected_tracker_ids, :project_id => project_ids, :fixed_version_id => @versions.map(&:id)).
                 order("#{Project.table_name}.lft, #{Tracker.table_name}.position, #{Issue.table_name}.id")

       attr_protected :id
       scope :visible, lambda {|*args|
         joins(:project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_messages, *args))
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         permission = :view_messages
         Project.enabled_modules_scope(all, permission).where(Project.allowed_to_condition(user, permission, options))
+      }
       safe_attributes 'name', 'description', 'parent_id', 'position'

       attr_protected :id
       scope :visible, lambda {|*args|
         joins(:repository => :project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_changesets, *args))
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         scope = if project_module = Redmine::AccessControl.permission(:view_changesets).try(:project_module)
           joins(:repository => {:project => :enabled_modules}).where(:enabled_modules => {:name => project_module})
         else
           joins(:repository => :project)
         end
         scope.where(Project.allowed_to_condition(user, :view_changesets, options))
+      }
       after_create :scan_for_issues

       after_create :send_notification
       scope :visible, lambda {|*args|
         joins(:project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_documents, *args))
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         permission = :view_documents
         Project.enabled_modules_scope(all, permission).where(Project.allowed_to_condition(user, permission, options))
+      }
       safe_attributes 'category_id', 'title', 'description', 'custom_fields', 'custom_field_values'

       attr_protected :id
       scope :visible, lambda {|*args|
         joins(:project).
         where(Issue.visible_condition(args.shift || User.current, *args))
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         Project.enabled_modules_scope(all, :view_issues).where(Issue.visible_condition(user, options))
+      }
       scope :open, lambda {|*args|
-...
       # Returns a scope of projects that user can assign issues to
       # If current_project is given, it will be included in the scope
       def self.allowed_target_projects(user=User.current, current_project=nil)
         condition = Project.allowed_to_condition(user, :add_issues)
         condition = Project.allowed_to_condition(user, :add_issues, :skip_pre_condition => true)
         if current_project
           condition = ["(#{condition}) OR #{Project.table_name}.id = ?", current_project.id]
         end
         Project.where(condition).having_trackers
         scope = Project
         if project_module = Redmine::AccessControl.permission(:add_issues).try(:project_module)
           scope = scope.joins(:enabled_modules).where(:enabled_modules => {:name => project_module})
         end
         scope.where(condition).having_trackers
       end
       # Returns a scope of trackers that user can assign the issue to

         user = args.shift || User.current
         options = args.shift || {}
         joins(:issue => :project).
         options[:skip_pre_condition] = true
         scope = if project_module = Redmine::AccessControl.permission(:view_issues).try(:project_module)
           joins(:issue => {:project => :enabled_modules}).where(:enabled_modules => {:name => project_module})
         else
           joins(:issue => :project)
         end
         scope.
           where(Issue.visible_condition(user, options)).
           where(Journal.visible_notes_condition(user, :skip_pre_condition => true))
+      }

       after_create :send_notification
       scope :visible, lambda {|*args|
         joins(:board => :project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_messages, *args))
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         scope = if project_module = Redmine::AccessControl.permission(:view_messages).try(:project_module)
           joins(:board => {:project => :enabled_modules}).where(:enabled_modules => {:name => project_module})
         else
           joins(:board => :project)
         end
         scope.where(Project.allowed_to_condition(user, :view_messages, options))
+      }
       safe_attributes 'subject', 'content'

       after_create :send_notification
       scope :visible, lambda {|*args|
         joins(:project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_news, *args))
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         permission = :view_news
         Project.enabled_modules_scope(all, permission).where(Project.allowed_to_condition(user, permission, options))
+      }
       safe_attributes 'title', 'summary', 'description'

       scope :active, lambda { where(:status => STATUS_ACTIVE) }
       scope :status, lambda {|arg| where(arg.blank? ? nil : {:status => arg.to_i}) }
       scope :all_public, lambda { where(:is_public => true) }
       scope :visible, lambda {|*args| where(Project.visible_condition(args.shift || User.current, *args)) }
       scope :visible, lambda { |*args|
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         scope = all
         if project_module = Redmine::AccessControl.permission(:view_project).try(:project_module)
           scope = scope.joins(:enabled_modules).where(:enabled_modules => {:name => project_module})
         end
         scope.where(Project.visible_condition(user, options))
+      }
       scope :allowed_to, lambda {|*args|
         user = User.current
         permission = nil
-...
         allowed_to_condition(user, :view_project, options)
       end
       def self.enabled_modules_scope(scope, permission)
         if project_module = Redmine::AccessControl.permission(permission).try(:project_module)
           scope.joins(:project => :enabled_modules).where(:enabled_modules => {:name => project_module})
         else
           scope.joins(:project)
         end
       end
       # Returns a SQL conditions string used to find all projects for which +user+ has the given +permission+
+      #
       # Valid options:

       validate :validate_time_entry
       scope :visible, lambda {|*args|
         joins(:project).
         where(TimeEntry.visible_condition(args.shift || User.current, *args))
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         permission = :view_time_entries
         Project.enabled_modules_scope(all, permission).where(TimeEntry.visible_condition(user, options))
+      }
       scope :left_join_issue, lambda {
         joins("LEFT OUTER JOIN #{Issue.table_name} ON #{Issue.table_name}.id = #{TimeEntry.table_name}.issue_id")

       #   => returns the trackers that are visible by the user in at least on project
       scope :visible, lambda {|*args|
         user = args.shift || User.current
         condition = Project.allowed_to_condition(user, :view_issues) do |role, user|
           unless role.permissions_all_trackers?(:view_issues)
             tracker_ids = role.permissions_tracker_ids(:view_issues)
         options = args.shift || {}
         options[:skip_pre_condition] = true
         permission = :view_issues
         condition = Project.allowed_to_condition(user, permission, options) do |role, user|
           unless role.permissions_all_trackers?(permission)
             tracker_ids = role.permissions_tracker_ids(permission)
             if tracker_ids.any?
               "#{Tracker.table_name}.id IN (#{tracker_ids.join(',')})"
             else
-...
             end
           end
         end
         joins(:projects).where(condition).distinct
         scope = if project_module = Redmine::AccessControl.permission(permission).try(:project_module)
           joins(:projects => :enabled_modules).where(:enabled_modules => {:name => project_module})
         else
           joins(:projects)
         end
         scope.where(condition).distinct
+      }
       safe_attributes 'name',

         end
+      }
       scope :visible, lambda {|*args|
         joins(:project).
         where(Project.allowed_to_condition(args.first || User.current, :view_issues))
         user = args.shift || User.current
         options = args.shift || {}
         options[:skip_pre_condition] = true
         permission = :view_issues
         Project.enabled_modules_scope(all, permission).where(Project.allowed_to_condition(user, permission, options))
+      }
       safe_attributes 'name',

Project

General

Profile

Redmine

Patch #26122 » joins_enabled_modules.patch