Class: Project

Inherits:
ApplicationRecord show all
Includes:
Redmine::NestedSet::ProjectNestedSet, Redmine::SafeAttributes
Defined in:
app/models/project.rb

Overview

Redmine - project management software Copyright © 2006- Jean-Philippe Lang

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

Constant Summary collapse

STATUS_ACTIVE =

Project statuses

1
STATUS_CLOSED = 
5
STATUS_ARCHIVED = 
9
STATUS_SCHEDULED_FOR_DELETION = 
10
IDENTIFIER_MAX_LENGTH =

Maximum length for project identifiers

100

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Redmine::NestedSet::ProjectNestedSet

included

Methods included from Redmine::SafeAttributes

#delete_unsafe_attributes, included, #safe_attribute?, #safe_attribute_names

Methods inherited from ApplicationRecord

human_attribute_name

Constructor Details

#initialize(attributes = nil, *args) ⇒ Project

Returns a new instance of Project.



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'app/models/project.rb', line 121

def initialize(attributes=nil, *args)
  super

  # rubocop:disable Style/NegatedIf
  initialized = (attributes || {}).stringify_keys
  if !initialized.key?('identifier') && Setting.sequential_project_identifiers?
    self.identifier = Project.next_identifier
  end
  if !initialized.key?('is_public')
    self.is_public = Setting.default_projects_public?
  end
  if !initialized.key?('enabled_module_names')
    self.enabled_module_names = Setting.default_projects_modules
  end
  if !initialized.key?('trackers') && !initialized.key?('tracker_ids')
    default = Setting.default_projects_tracker_ids
    if default.is_a?(Array)
      self.trackers = Tracker.where(:id => default.map(&:to_i)).sorted.to_a
    else
      self.trackers = Tracker.sorted.to_a
    end
  end
  # rubocop:enable Style/NegatedIf
end

Class Method Details

.allowed_to_condition(user, permission, options = {}) ⇒ Object

Returns a SQL conditions string used to find all projects for which user has the given permission

Valid options:

  • :skip_pre_condition => true don’t check that the module is enabled (eg. when the condition is already set elsewhere in the query)

  • :project => project limit the condition to project

  • :with_subprojects => true limit the condition to project and its subprojects

  • :member => true limit the condition to the user projects



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'app/models/project.rb', line 185

def self.allowed_to_condition(user, permission, options={})
  perm = Redmine::AccessControl.permission(permission)
  base_statement =
    if perm && perm.read?
      "#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED} AND #{Project.table_name}.status <> #{Project::STATUS_SCHEDULED_FOR_DELETION}"
    else
      "#{Project.table_name}.status = #{Project::STATUS_ACTIVE}"
    end
  if !options[:skip_pre_condition] && perm && perm.project_module
    # If the permission belongs to a project module, make sure the module is enabled
    base_statement +=
      " AND EXISTS (SELECT 1 AS one FROM #{EnabledModule.table_name} em" \
        " WHERE em.project_id = #{Project.table_name}.id" \
        " AND em.name='#{perm.project_module}')"
  end
  if project = options[:project]
    project_statement = project.project_condition(options[:with_subprojects])
    base_statement = "(#{project_statement}) AND (#{base_statement})"
  end

  if user.admin?
    base_statement
  else
    statement_by_role = {}
    unless options[:member]
      role = user.builtin_role
      if role.allowed_to?(permission)
        s = "#{Project.table_name}.is_public = #{connection.quoted_true}"
        if user.id
          group = role.anonymous? ? Group.anonymous : Group.non_member
          principal_ids = [user.id, group.id].compact
          s =
            "(#{s} AND #{Project.table_name}.id NOT IN " \
              "(SELECT project_id FROM #{Member.table_name} " \
              "WHERE user_id IN (#{principal_ids.join(',')})))"
        end
        statement_by_role[role] = s
      end
    end
    user.project_ids_by_role.each do |role, project_ids|
      if role.allowed_to?(permission) && project_ids.any?
        statement_by_role[role] = "#{Project.table_name}.id IN (#{project_ids.join(',')})"
      end
    end
    if statement_by_role.empty?
      "1=0"
    else
      if block_given?
        statement_by_role.each do |role, statement|
          if s = yield(role, user)
            statement_by_role[role] = "(#{statement} AND (#{s}))"
          end
        end
      end
      "((#{base_statement}) AND (#{statement_by_role.values.join(' OR ')}))"
    end
  end
end

.copy_from(project) ⇒ Object

Returns a new unsaved Project instance with attributes copied from project



959
960
961
962
963
964
965
966
967
968
969
970
971
 
# File 'app/models/project.rb', line 959

def self.copy_from(project)
  project = Project.find(project) unless project.is_a?(Project)
  # clear unique attributes
  attributes =
    project.attributes.dup.except('id', 'name', 'identifier',
                                  'status', 'parent_id', 'lft', 'rgt')
  copy = Project.new(attributes)
  copy.enabled_module_names = project.enabled_module_names
  copy.trackers = project.trackers
  copy.custom_values = project.custom_values.collect {|v| v.clone}
  copy.issue_custom_fields = project.issue_custom_fields
  copy
end

.default_member_role ⇒ Object

Default role that is given to non-admin users that create a project



585
586
587
 
# File 'app/models/project.rb', line 585

def self.default_member_role
  Role.givable.find_by_id(Setting.new_project_user_role_id.to_i) || Role.givable.first
end

.find(*args) ⇒ Object 



348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'app/models/project.rb', line 348

def self.find(*args)
  if args.first && args.first.is_a?(String) && !/^\d*$/.match?(args.first)
    project = find_by_identifier(*args)
    if project.nil?
      raise ActiveRecord::RecordNotFound, "Couldn't find Project with identifier=#{args.first}"
    end

    project
  else
    super
  end
end

.find_by_param(*args) ⇒ Object 



361
362
363
 
# File 'app/models/project.rb', line 361

def self.find_by_param(*args)
  self.find(*args)
end

.latest(user = nil, count = 5) ⇒ Object

returns latest created projects non public projects will be returned only if user is a member of those



156
157
158
159
160
161
 
# File 'app/models/project.rb', line 156

def self.latest(user=nil, count=5)
  visible(user).limit(count).
    order(:created_on => :desc).
    where("#{table_name}.created_on >= ?", 30.days.ago).
    to_a
end

.load_last_activity_date(projects, user = User.current) ⇒ Object

Preloads last activity date for a collection of projects



1017
1018
1019
1020
1021
1022
1023
1024
 
# File 'app/models/project.rb', line 1017

def self.load_last_activity_date(projects, user=User.current)
  if projects.any?
    last_activities = Redmine::Activity::Fetcher.new(User.current).events(nil, nil, :last_by_project => true).to_h
    projects.each do |project|
      project.instance_variable_set(:@last_activity_date, last_activities[project.id])
    end
  end
end

.next_identifier ⇒ Object

Returns an auto-generated project identifier based on the last identifier used



911
912
913
914
 
# File 'app/models/project.rb', line 911

def self.next_identifier
  p = Project.order('id DESC').first
  p.nil? ? nil : p.identifier.to_s.succ
end

.project_tree(projects, options = {}, &block) ⇒ Object

Yields the given block for each project with its level in the tree



974
975
976
977
978
979
980
981
982
983
984
985
986
987
 
# File 'app/models/project.rb', line 974

def self.project_tree(projects, options={}, &block)
  ancestors = []
  if options[:init_level] && projects.first
    ancestors = projects.first.ancestors.to_a
  end
  projects.sort_by(&:lft).each do |project|
    while ancestors.any? &&
           !project.is_descendant_of?(ancestors.last)
      ancestors.pop
    end
    yield project, ancestors.size
    ancestors << project
  end
end

.visible_condition(user, options = {}) ⇒ Object

Returns a SQL conditions string used to find all projects visible by the specified user.

Examples:

Project.visible_condition(admin)        => "projects.status = 1"
Project.visible_condition(normal_user)  => "((projects.status = 1) AND (projects.is_public = 1 OR projects.id IN (1,3,4)))"
Project.visible_condition(anonymous)    => "((projects.status = 1) AND (projects.is_public = 1))"



174
175
176
 
# File 'app/models/project.rb', line 174

def self.visible_condition(user, options={})
  allowed_to_condition(user, :view_project, options)
end

Instance Method Details

#<=>(project) ⇒ Object 



672
673
674
675
676
 
# File 'app/models/project.rb', line 672

def <=>(project)
  return nil unless project.is_a?(Project)

  name.casecmp(project.name)
end

#active? ⇒ Boolean

Returns:

  • (Boolean) 


397
398
399
 
# File 'app/models/project.rb', line 397

def active?
  self.status == STATUS_ACTIVE
end

#activities(include_inactive = false) ⇒ Object

Returns the Systemwide and project specific activities



265
266
267
268
269
270
271
272
273
274
275
276
277
 
# File 'app/models/project.rb', line 265

def activities(include_inactive=false)
  t = TimeEntryActivity.table_name
  scope = TimeEntryActivity.where("#{t}.project_id IS NULL OR #{t}.project_id = ?", id)

  overridden_activity_ids = self.time_entry_activities.pluck(:parent_id).compact
  if overridden_activity_ids.any?
    scope = scope.where("#{t}.id NOT IN (?)", overridden_activity_ids)
  end
  unless include_inactive
    scope = scope.active
  end
  scope
end

#add_default_member(user) ⇒ Object

Adds user as a project member with the default role Used for when a non-admin user creates a project



576
577
578
579
580
581
 
# File 'app/models/project.rb', line 576

def add_default_member(user)
  role = self.class.default_member_role
  member = Member.new(:project => self, :principal => user, :roles => [role])
  self.members << member
  member
end

#all_issue_custom_fields ⇒ Object

Returns a scope of all custom fields enabled for project issues (explicitly associated custom fields and custom fields enabled for all projects)



638
639
640
641
642
643
644
645
646
647
648
649
650
 
# File 'app/models/project.rb', line 638

def all_issue_custom_fields
  if new_record?
    @all_issue_custom_fields ||= IssueCustomField.
      sorted.
      where("is_for_all = ? OR id IN (?)", true, issue_custom_field_ids)
  else
    @all_issue_custom_fields ||= IssueCustomField.
      sorted.
      where("is_for_all = ? OR id IN (SELECT DISTINCT cfp.custom_field_id" +
        " FROM #{table_name_prefix}custom_fields_projects#{table_name_suffix} cfp" +
        " WHERE cfp.project_id = ?)", true, id)
  end
end

#allowed_parents(user = User.current) ⇒ Object

Returns an array of projects the project can be moved to by the current user



451
452
453
454
455
456
457
458
459
460
461
462
463
 
# File 'app/models/project.rb', line 451

def allowed_parents(user=User.current)
  return @allowed_parents if @allowed_parents

  @allowed_parents = Project.allowed_to(user, :add_subprojects).to_a
  @allowed_parents = @allowed_parents - self_and_descendants
  if user.allowed_to?(:add_project, nil, :global => true) || (!new_record? && parent.nil?)
    @allowed_parents << nil
  end
  unless parent.nil? || @allowed_parents.empty? || @allowed_parents.include?(parent)
    @allowed_parents << parent
  end
  @allowed_parents
end

#allows_to?(action) ⇒ Boolean

Return true if this project allows to do the specified action. action can be:

  • a parameter-like Hash (eg. :controller => ‘projects’, :action => ‘edit’)

  • a permission Symbol (eg. :edit_project)

Returns:

  • (Boolean) 


749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
 
# File 'app/models/project.rb', line 749

def allows_to?(action)
  if archived?
    # No action allowed on archived projects
    return false
  end
  unless active? || Redmine::AccessControl.read_action?(action)
    # No write action allowed on closed projects
    return false
  end

  # No action allowed on disabled modules
  if action.is_a? Hash
    allowed_actions.include? "#{action[:controller]}/#{action[:action]}"
  else
    allowed_permissions.include? action
  end
end

#archive ⇒ Object

Archives the project and its descendants



414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
 
# File 'app/models/project.rb', line 414

def archive
  # Check that there is no issue of a non descendant project that is assigned
  # to one of the project or descendant versions
  version_ids = self_and_descendants.joins(:versions).pluck("#{Version.table_name}.id")

  if version_ids.any? &&
    Issue.
      joins(:project).
      where("#{Project.table_name}.lft < ? OR #{Project.table_name}.rgt > ?", lft, rgt).
      where(:fixed_version_id => version_ids).
      exists?
    return false
  end

  Project.transaction do
    archive!
  end
  true
end

#archived? ⇒ Boolean

Returns:

  • (Boolean) 


405
406
407
 
# File 'app/models/project.rb', line 405

def archived?
  self.status == STATUS_ARCHIVED
end

#assignable_users(tracker = nil) ⇒ Object

Return a Principal scope of users/groups issues can be assigned to



600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
 
# File 'app/models/project.rb', line 600

def assignable_users(tracker=nil)
  return @assignable_users[tracker] if @assignable_users && @assignable_users[tracker]

  types = ['User']
  types << 'Group' if Setting.issue_group_assignment?

  scope = Principal.
    active.
    joins(:members => :roles).
    where(:type => types, :members => {:project_id => id}, :roles => {:assignable => true}).
    distinct.
    sorted

  if tracker
    # Rejects users that cannot the view the tracker
    roles =
      Role.where(:assignable => true).select do |role|
        role.permissions_tracker?(:view_issues, tracker)
      end
    scope = scope.where(:roles => {:id => roles.map(&:id)})
  end

  @assignable_users ||= {}
  @assignable_users[tracker] = scope
end

#base_reload ⇒ Object 



365
 
# File 'app/models/project.rb', line 365

alias :base_reload :reload

#close ⇒ Object 



441
442
443
 
# File 'app/models/project.rb', line 441

def close
  self_and_descendants.status(STATUS_ACTIVE).update_all :status => STATUS_CLOSED
end

#close_completed_versions ⇒ Object

Closes open and locked project versions that are completed



509
510
511
512
513
514
515
516
517
 
# File 'app/models/project.rb', line 509

def close_completed_versions
  Version.transaction do
    versions.where(:status => %w(open locked)).each do |version|
      if version.completed?
        version.update_attribute(:status, 'closed')
      end
    end
  end
end

#closed? ⇒ Boolean

Returns:

  • (Boolean) 


401
402
403
 
# File 'app/models/project.rb', line 401

def closed?
  self.status == STATUS_CLOSED
end

#commit_logtime_activity ⇒ Object

returns the time log activity to be used when logging time via a changeset



324
325
326
327
328
329
330
 
# File 'app/models/project.rb', line 324

def commit_logtime_activity
  activity_id = Setting.commit_logtime_activity_id.to_i
  if activity_id > 0
    activities
      .find_by('id = ? OR parent_id = ?', activity_id, activity_id)
  end
end

#completed_percent(options = {:include_subprojects => false}) ⇒ Object

Returns the percent completed for this project, based on the progress on it’s versions.



729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
 
# File 'app/models/project.rb', line 729

def completed_percent(options={:include_subprojects => false})
  if options.delete(:include_subprojects)
    total = self_and_descendants.sum(&:completed_percent)

    total / self_and_descendants.count
  else
    if versions.count > 0
      total = versions.sum(&:completed_percent)

      total / versions.count
    else
      100
    end
  end
end

#copy(project, options = {}) ⇒ Object

Copies and saves the Project instance based on the project. Duplicates the source project’s:

  • Wiki

  • Versions

  • Categories

  • Issues

  • Members

  • Queries

Accepts an options argument to specify what to copy

Examples:

project.copy(1)                                    # => copies everything
project.copy(1, :only => 'members')                # => copies members only
project.copy(1, :only => ['members', 'versions'])  # => copies members and versions



931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
 
# File 'app/models/project.rb', line 931

def copy(project, options={})
  project = Project.find(project) unless project.is_a?(Project)

  to_be_copied = %w(members wiki versions issue_categories issues queries boards documents)
  to_be_copied = to_be_copied & Array.wrap(options[:only]) unless options[:only].nil?

  Project.transaction do
    if save
      reload

      self.attachments = project.attachments.map do |attachment|
        attachment.copy(:container => self)
      end

      to_be_copied.each do |name|
        send :"copy_#{name}", project
      end
      Redmine::Hook.call_hook(:model_project_copy_before_save,
                              :source_project => project,
                              :destination_project => self)
      save
    else
      false
    end
  end
end

#create_time_entry_activity_if_needed(activity) ⇒ Object

Create a new TimeEntryActivity if it overrides a system TimeEntryActivity

This will raise a ActiveRecord::Rollback if the TimeEntryActivity does not successfully save.



305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
 
# File 'app/models/project.rb', line 305

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.overriding_change?(activity, parent_activity)
      project_activity = self.time_entry_activities.create(activity)
      if project_activity.new_record?
        raise ActiveRecord::Rollback, "Overriding TimeEntryActivity was not successfully saved"
      else
        self.time_entries.
          where(:activity_id => parent_activity.id).
          update_all(:activity_id => project_activity.id)
      end
    end
  end
end

#css_classes ⇒ Object 



687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
 
# File 'app/models/project.rb', line 687

def css_classes
  s = +'project'
  s << ' root' if root?
  s << ' child' if child?
  s << (leaf? ? ' leaf' : ' parent')
  s << ' public' if is_public?
  unless active?
    if archived?
      s << ' archived'
    else
      s << ' closed'
    end
  end
  s
end

#deletable?(user = User.current) ⇒ Boolean

Returns:

  • (Boolean) 


767
768
769
770
771
772
773
 
# File 'app/models/project.rb', line 767

def deletable?(user = User.current)
  if user.admin?
    return true
  else
    user.allowed_to?(:delete_project, self) && leaf?
  end
end

#delete_all_members ⇒ Object

Deletes all project’s members



590
591
592
593
594
595
596
597
 
# File 'app/models/project.rb', line 590

def delete_all_members
  me, mr = Member.table_name, MemberRole.table_name
  self.class.connection.delete(
    "DELETE FROM #{mr} WHERE #{mr}.member_id IN (SELECT #{me}.id FROM #{me} " \
      "WHERE #{me}.project_id = #{id})"
  )
  Member.where(:project_id => id).delete_all
end

#disable_module!(target) ⇒ Object

Disable a module if it exists

Examples:

project.disable_module!(:issue_tracking)
project.disable_module!("issue_tracking")
project.disable_module!(project.enabled_modules.first)



820
821
822
823
 
# File 'app/models/project.rb', line 820

def disable_module!(target)
  target = enabled_modules.detect{|mod| target.to_s == mod.name} unless enabled_modules.include?(target)
  target.destroy unless target.blank?
end

#due_date ⇒ Object

The latest due date of an issue or version



714
715
716
717
718
719
720
721
 
# File 'app/models/project.rb', line 714

def due_date
  @due_date ||=
    [
      issues.maximum('due_date'),
      shared_versions.maximum('effective_date'),
      Issue.fixed_version(shared_versions).maximum('due_date')
    ].compact.max
end

#editable_custom_field_values(user = nil) ⇒ Object

Returns the custom_field_values that can be edited by the given user



1001
1002
1003
 
# File 'app/models/project.rb', line 1001

def editable_custom_field_values(user=nil)
  visible_custom_field_values(user)
end

#enable_module!(name) ⇒ Object

Enable a specific module

Examples:

project.enable_module!(:issue_tracking)
project.enable_module!("issue_tracking")



810
811
812
 
# File 'app/models/project.rb', line 810

def enable_module!(name)
  enabled_modules << EnabledModule.new(:name => name.to_s) unless module_enabled?(name)
end

#enabled_module(name) ⇒ Object

Return the enabled module with the given name or nil if the module is not enabled for the project



777
778
779
780
 
# File 'app/models/project.rb', line 777

def enabled_module(name)
  name = name.to_s
  enabled_modules.detect {|m| m.name == name}
end

#enabled_module_names ⇒ Object

Returns an array of the enabled modules names



801
802
803
 
# File 'app/models/project.rb', line 801

def enabled_module_names
  enabled_modules.collect(&:name)
end

#enabled_module_names=(module_names) ⇒ Object 



787
788
789
790
791
792
793
794
795
796
797
798
 
# File 'app/models/project.rb', line 787

def enabled_module_names=(module_names)
  if module_names && module_names.is_a?(Array)
    module_names = module_names.collect(&:to_s).reject(&:blank?)
    self.enabled_modules =
      module_names.collect do |name|
        enabled_modules.detect {|mod| mod.name == name} ||
          EnabledModule.new(:name => name)
      end
  else
    enabled_modules.clear
  end
end

#identifier=(identifier) ⇒ Object 



146
147
148
 
# File 'app/models/project.rb', line 146

def identifier=(identifier)
  super unless identifier_frozen?
end

#identifier_frozen? ⇒ Boolean

Returns:

  • (Boolean) 


150
151
152
 
# File 'app/models/project.rb', line 150

def identifier_frozen?
  errors[:identifier].blank? && !(new_record? || identifier.blank?)
end

#last_activity_date ⇒ Object 



1012
1013
1014
 
# File 'app/models/project.rb', line 1012

def last_activity_date
  @last_activity_date || fetch_last_activity_date
end

#module_enabled?(name) ⇒ Boolean

Return true if the module with the given name is enabled

Returns:

  • (Boolean) 


783
784
785
 
# File 'app/models/project.rb', line 783

def module_enabled?(name)
  enabled_module(name).present?
end

#notified_users ⇒ Object

Returns the users that should be notified on project events



632
633
634
 
# File 'app/models/project.rb', line 632

def notified_users
  users.where('members.mail_notification = ? OR users.mail_notification = ?', true, 'all')
end

#overdue? ⇒ Boolean

Returns:

  • (Boolean) 


723
724
725
 
# File 'app/models/project.rb', line 723

def overdue?
  active? && !due_date.nil? && (due_date < User.current.today)
end

#override_roles(role) ⇒ Object 



244
245
246
247
248
249
250
251
252
 
# File 'app/models/project.rb', line 244

def override_roles(role)
  @override_members ||= memberships.
    joins(:principal).
    where(:users => {:type => ['GroupAnonymous', 'GroupNonMember']}).to_a

  group_class = role.anonymous? ? GroupAnonymous : GroupNonMember
  member = @override_members.detect {|m| m.principal.is_a? group_class}
  member ? member.roles.to_a : [role]
end

#principals ⇒ Object 



254
255
256
257
 
# File 'app/models/project.rb', line 254

def principals
  @principals ||=
    Principal.active.joins(:members).where("#{Member.table_name}.project_id = ?", id).distinct
end

#principals_by_role ⇒ Object

Returns a hash of project users/groups grouped by role



564
565
566
567
568
569
570
571
572
 
# File 'app/models/project.rb', line 564

def principals_by_role
  memberships.active.includes(:principal, :roles).inject({}) do |h, m|
    m.roles.each do |r|
      h[r] ||= []
      h[r] << m.principal
    end
    h
  end
end

#project ⇒ Object 



668
669
670
 
# File 'app/models/project.rb', line 668

def project
  self
end

#project_condition(with_subprojects) ⇒ Object

Returns a :conditions SQL string that can be used to find the issues associated with this project.

Examples:

project.project_condition(true)  => "(projects.lft >= 1 AND projects.rgt <= 10)"
project.project_condition(false) => "projects.id = 1"



337
338
339
340
341
342
343
344
345
346
 
# File 'app/models/project.rb', line 337

def project_condition(with_subprojects)
  if with_subprojects
    "(" \
      "#{Project.table_name}.lft >= #{lft} AND " \
      "#{Project.table_name}.rgt <= #{rgt}" \
    ")"
  else
    "#{Project.table_name}.id = #{id}"
  end
end

#recipients ⇒ Object

Returns the mail addresses of users that should be always notified on project events



627
628
629
 
# File 'app/models/project.rb', line 627

def recipients
  notified_users.collect {|user| user.mail}
end

#reload(*args) ⇒ Object 



366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
 
# File 'app/models/project.rb', line 366

def reload(*args)
  @principals = nil
  @users = nil
  @shared_versions = nil
  @rolled_up_versions = nil
  @rolled_up_trackers = nil
  @rolled_up_statuses = nil
  @rolled_up_custom_fields = nil
  @all_issue_custom_fields = nil
  @all_time_entry_custom_fields = nil
  @to_param = nil
  @allowed_parents = nil
  @allowed_permissions = nil
  @actions_allowed = nil
  @start_date = nil
  @due_date = nil
  @override_members = nil
  @assignable_users = nil
  @last_activity_date = nil
  base_reload(*args)
end

#reopen ⇒ Object 



445
446
447
 
# File 'app/models/project.rb', line 445

def reopen
  self_and_descendants.status(STATUS_CLOSED).update_all :status => STATUS_ACTIVE
end

#rolled_up_custom_fields ⇒ Object

Returns a scope of all custom fields enabled for issues of the project and its subprojects



654
655
656
657
658
659
660
661
662
663
664
665
666
 
# File 'app/models/project.rb', line 654

def rolled_up_custom_fields
  if leaf?
    all_issue_custom_fields
  else
    @rolled_up_custom_fields ||= IssueCustomField.
      sorted.
      where("is_for_all = ? OR EXISTS (SELECT 1" +
        " FROM #{table_name_prefix}custom_fields_projects#{table_name_suffix} cfp" +
        " JOIN #{Project.table_name} p ON p.id = cfp.project_id" +
        " WHERE cfp.custom_field_id = #{CustomField.table_name}.id" +
        " AND p.lft >= ? AND p.rgt <= ?)", true, lft, rgt)
  end
end

#rolled_up_statuses ⇒ Object 



496
497
498
499
500
501
502
503
504
505
506
 
# File 'app/models/project.rb', line 496

def rolled_up_statuses
  issue_status_ids = WorkflowTransition.
    where(:tracker_id => rolled_up_trackers.map(&:id)).
    where('old_status_id <> new_status_id').
    distinct.
    pluck(:old_status_id, :new_status_id).
    flatten.
    uniq

  IssueStatus.where(:id => issue_status_ids).sorted
end

#rolled_up_trackers(include_subprojects = true) ⇒ Object

Returns a scope of the trackers used by the project and its active sub projects



477
478
479
480
481
482
483
484
485
 
# File 'app/models/project.rb', line 477

def rolled_up_trackers(include_subprojects=true)
  if include_subprojects
    @rolled_up_trackers ||= rolled_up_trackers_base_scope.
        where("#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ?", lft, rgt)
  else
    rolled_up_trackers_base_scope.
      where(:projects => {:id => id})
  end
end

#rolled_up_trackers_base_scope ⇒ Object 



487
488
489
490
491
492
493
494
 
# File 'app/models/project.rb', line 487

def rolled_up_trackers_base_scope
  Tracker.
    joins(projects: :enabled_modules).
    where("#{Project.table_name}.status <> ?", STATUS_ARCHIVED).
    where(:enabled_modules => {:name => 'issue_tracking'}).
    distinct.
    sorted
end

#rolled_up_versions ⇒ Object

Returns a scope of the Versions on subprojects



520
521
522
523
524
525
526
527
528
 
# File 'app/models/project.rb', line 520

def rolled_up_versions
  @rolled_up_versions ||=
    Version.
      joins(:project).
      where(
        "#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ?" \
        " AND #{Project.table_name}.status <> ?", lft, rgt, STATUS_ARCHIVED
      )
end

#safe_attributes=(attrs, user = User.current) ⇒ Object 



875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
 
# File 'app/models/project.rb', line 875

def safe_attributes=(attrs, user=User.current)
  if attrs.respond_to?(:to_unsafe_hash)
    attrs = attrs.to_unsafe_hash
  end
  return unless attrs.is_a?(Hash)

  attrs = attrs.deep_dup

  @unallowed_parent_id = nil
  if new_record? || attrs.key?('parent_id')
    parent_id_param = attrs['parent_id'].to_s
    if new_record? || parent_id_param != parent_id.to_s
      p = parent_id_param.present? ? Project.find_by_id(parent_id_param) : nil
      unless allowed_parents(user).include?(p)
        attrs.delete('parent_id')
        @unallowed_parent_id = true
      end
    end
  end

  # Reject custom fields values not visible by the user
  if attrs['custom_field_values'].present?
    editable_custom_field_ids = editable_custom_field_values(user).map {|v| v.custom_field_id.to_s}
    attrs['custom_field_values'].reject! {|k, v| !editable_custom_field_ids.include?(k.to_s)}
  end

  # Reject custom fields not visible by the user
  if attrs['custom_fields'].present?
    editable_custom_field_ids = editable_custom_field_values(user).map {|v| v.custom_field_id.to_s}
    attrs['custom_fields'].reject! {|c| !editable_custom_field_ids.include?(c['id'].to_s)}
  end

  super
end

#scheduled_for_deletion? ⇒ Boolean

Returns:

  • (Boolean) 


409
410
411
 
# File 'app/models/project.rb', line 409

def scheduled_for_deletion?
  self.status == STATUS_SCHEDULED_FOR_DELETION
end

#set_parent!(p) ⇒ Object

Sets the parent of the project and saves the project Argument can be either a Project, a String, a Fixnum or nil



467
468
469
470
471
472
473
474
 
# File 'app/models/project.rb', line 467

def set_parent!(p)
  if p.is_a?(Project)
    self.parent = p
  else
    self.parent_id = p
  end
  save
end

#shared_versions ⇒ Object

Returns a scope of the Versions used by the project



531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
 
# File 'app/models/project.rb', line 531

def shared_versions
  if new_record?
    Version.
      joins(:project).
      preload(:project).
      where("#{Project.table_name}.status <> ? AND #{Version.table_name}.sharing = 'system'",
            STATUS_ARCHIVED)
  else
    @shared_versions ||= begin
      r = root? ? self : root
      Version.
        joins(:project).
        preload(:project).
        where(
          "#{Project.table_name}.id = #{id}" \
          " OR (#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED} AND (" \
          " #{Version.table_name}.sharing = 'system'" \
          " OR (#{Project.table_name}.lft >= #{r.lft}" \
          " AND #{Project.table_name}.rgt <= #{r.rgt}" \
          " AND #{Version.table_name}.sharing = 'tree')" \
          " OR (#{Project.table_name}.lft < #{lft}" \
          " AND #{Project.table_name}.rgt > #{rgt}" \
          " AND #{Version.table_name}.sharing IN ('hierarchy', 'descendants'))" \
          " OR (#{Project.table_name}.lft > #{lft}" \
          " AND #{Project.table_name}.rgt < #{rgt}" \
          " AND #{Version.table_name}.sharing = 'hierarchy')" \
          "))"
        )
    end
  end
end

#short_description(length = 255) ⇒ Object

Returns a short description of the projects (first lines)



683
684
685
 
# File 'app/models/project.rb', line 683

def short_description(length = 255)
  description.gsub(/^(.{#{length}}[^\n\r]*).*$/m, '\1...').strip if description
end

#start_date ⇒ Object

The earliest start date of a project, based on it’s issues and versions



704
705
706
707
708
709
710
711
 
# File 'app/models/project.rb', line 704

def start_date
  @start_date ||=
    [
      issues.minimum('start_date'),
      shared_versions.minimum('effective_date'),
      Issue.fixed_version(shared_versions).minimum('start_date')
    ].compact.min
end

#to_param ⇒ Object 



388
389
390
391
392
393
394
395
 
# File 'app/models/project.rb', line 388

def to_param
  if new_record?
    nil
  else
    # id is used for projects with a numeric identifier (compatibility)
    @to_param ||= (%r{^\d*$}.match?(identifier.to_s) ? id.to_s : identifier)
  end
end

#to_s ⇒ Object 



678
679
680
 
# File 'app/models/project.rb', line 678

def to_s
  name
end

#unarchive ⇒ Object

Unarchives the project and its archived ancestors



435
436
437
438
439
 
# File 'app/models/project.rb', line 435

def unarchive
  new_status = ancestors.any?(&:closed?) ? STATUS_CLOSED : STATUS_ACTIVE
  self_and_ancestors.status(STATUS_ARCHIVED).update_all :status => new_status
  reload
end

#update_or_create_time_entry_activities(activities) ⇒ Object

Creates or updates project time entry activities



280
281
282
283
284
285
286
 
# File 'app/models/project.rb', line 280

def update_or_create_time_entry_activities(activities)
  transaction do
    activities.each do |id, activity|
      update_or_create_time_entry_activity(id, activity)
    end
  end
end

#update_or_create_time_entry_activity(id, activity_hash) ⇒ Object

Will create a new Project specific Activity or update an existing one

This will raise a ActiveRecord::Rollback if the TimeEntryActivity does not successfully save.



292
293
294
295
296
297
298
299
 
# File 'app/models/project.rb', line 292

def update_or_create_time_entry_activity(id, activity_hash)
  if activity_hash.respond_to?(:has_key?) && activity_hash.has_key?('parent_id')
    self.create_time_entry_activity_if_needed(activity_hash)
  else
    activity = project.time_entry_activities.find_by_id(id.to_i)
    activity.update(activity_hash) if activity
  end
end

#users ⇒ Object 



259
260
261
262
 
# File 'app/models/project.rb', line 259

def users
  @users ||=
    User.active.joins(:members).where("#{Member.table_name}.project_id = ?", id).distinct
end

#validate_custom_field_values ⇒ Object

Overrides Redmine::Acts::Customizable::InstanceMethods#validate_custom_field_values so that custom values that are not editable are not validated (eg. a custom field that is marked as required should not trigger a validation error if the user is not allowed to edit this field).



993
994
995
996
997
998
 
# File 'app/models/project.rb', line 993

def validate_custom_field_values
  user = User.current
  if new_record? || custom_field_values_changed?
    editable_custom_field_values(user).each(&:validate_value)
  end
end

#visible?(user = User.current) ⇒ Boolean

Returns true if the project is visible to user or to the current user.

Returns:

  • (Boolean) 


164
165
166
 
# File 'app/models/project.rb', line 164

def visible?(user=User.current)
  user.allowed_to?(:view_project, self)
end

#visible_custom_field_values(user = nil) ⇒ Object 



1005
1006
1007
1008
1009
1010
 
# File 'app/models/project.rb', line 1005

def visible_custom_field_values(user = nil)
  user ||= User.current
  custom_field_values.select do |value|
    value.custom_field.visible_by?(project, user)
  end
end