Class: Project

Inherits:
ActiveRecord::Base
  • Object
show all
Includes:
Redmine::NestedSet::ProjectNestedSet, Redmine::SafeAttributes
Defined in:
app/models/project.rb

Overview

Redmine - project management software Copyright (C) 2006-2020 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
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

Constructor Details

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

Returns a new instance of Project.


111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
# File 'app/models/project.rb', line 111

def initialize(attributes=nil, *args)
  super

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


173
174
175
176
177
178
179
180
181
182
183
184
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
# File 'app/models/project.rb', line 173

def self.allowed_to_condition(user, permission, options={})
  perm = Redmine::AccessControl.permission(permission)
  base_statement = (perm && perm.read? ? "#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED}" : "#{Project.table_name}.status = #{Project::STATUS_ACTIVE}")
  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


873
874
875
876
877
878
879
880
881
882
883
# File 'app/models/project.rb', line 873

def self.copy_from(project)
  project = project.is_a?(Project) ? project : Project.find(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_roleObject

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


538
539
540
# File 'app/models/project.rb', line 538

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


318
319
320
321
322
323
324
325
326
# File 'app/models/project.rb', line 318

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

.find_by_param(*args) ⇒ Object


328
329
330
# File 'app/models/project.rb', line 328

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


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

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

.next_identifierObject

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


827
828
829
830
# File 'app/models/project.rb', line 827

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


886
887
888
889
890
891
892
893
894
895
896
897
898
899
# File 'app/models/project.rb', line 886

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

162
163
164
# File 'app/models/project.rb', line 162

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

Instance Method Details

#<=>(project) ⇒ Object


620
621
622
# File 'app/models/project.rb', line 620

def <=>(project)
  name.casecmp(project.name)
end

#active?Boolean

Returns:

  • (Boolean)

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

def active?
  self.status == STATUS_ACTIVE
end

#activities(include_inactive = false) ⇒ Object

Returns the Systemwide and project specific activities


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

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


529
530
531
532
533
534
# File 'app/models/project.rb', line 529

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_fieldsObject

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


586
587
588
589
590
591
592
593
594
595
596
597
598
# File 'app/models/project.rb', line 586

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


412
413
414
415
416
417
418
419
420
421
422
423
# File 'app/models/project.rb', line 412

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)

695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
# File 'app/models/project.rb', line 695

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

#archiveObject

Archives the project and its descendants


376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
# File 'app/models/project.rb', line 376

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)

371
372
373
# File 'app/models/project.rb', line 371

def archived?
  self.status == STATUS_ARCHIVED
end

#assignable_users(tracker = nil) ⇒ Object

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


550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
# File 'app/models/project.rb', line 550

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 {|role| role.permissions_tracker?(:view_issues, tracker)}
    scope = scope.where(:roles => {:id => roles.map(&:id)})
  end

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

#base_reloadObject


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

alias :base_reload :reload

#closeObject


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

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

#close_completed_versionsObject

Closes open and locked project versions that are completed


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

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)

367
368
369
# File 'app/models/project.rb', line 367

def closed?
  self.status == STATUS_CLOSED
end

#commit_logtime_activityObject

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


299
300
301
302
303
304
305
# File 'app/models/project.rb', line 299

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.


675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
# File 'app/models/project.rb', line 675

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

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

      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

847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
# File 'app/models/project.rb', line 847

def copy(project, options={})
  project = project.is_a?(Project) ? project : Project.find(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.


280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
# File 'app/models/project.rb', line 280

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_classesObject


633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
# File 'app/models/project.rb', line 633

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

#delete_all_membersObject

Deletes all project's members


543
544
545
546
547
# File 'app/models/project.rb', line 543

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)

753
754
755
756
# File 'app/models/project.rb', line 753

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_dateObject

The latest due date of an issue or version


660
661
662
663
664
665
666
667
# File 'app/models/project.rb', line 660

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


902
903
904
# File 'app/models/project.rb', line 902

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

743
744
745
# File 'app/models/project.rb', line 743

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


714
715
716
717
# File 'app/models/project.rb', line 714

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

#enabled_module_namesObject

Returns an array of the enabled modules names


734
735
736
# File 'app/models/project.rb', line 734

def enabled_module_names
  enabled_modules.collect(&:name)
end

#enabled_module_names=(module_names) ⇒ Object


724
725
726
727
728
729
730
731
# File 'app/models/project.rb', line 724

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 {|name| enabled_modules.detect {|mod| mod.name == name} || EnabledModule.new(:name => name)}
  else
    enabled_modules.clear
  end
end

#identifier=(identifier) ⇒ Object


134
135
136
# File 'app/models/project.rb', line 134

def identifier=(identifier)
  super unless identifier_frozen?
end

#identifier_frozen?Boolean

Returns:

  • (Boolean)

138
139
140
# File 'app/models/project.rb', line 138

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

#members_by_roleObject

TODO: Remove this method in Redmine 5.0


522
523
524
525
# File 'app/models/project.rb', line 522

def members_by_role
  ActiveSupport::Deprecation.warn "Project#members_by_role will be removed. Use Project#principals_by_role instead."
  principals_by_role
end

#module_enabled?(name) ⇒ Boolean

Return true if the module with the given name is enabled

Returns:

  • (Boolean)

720
721
722
# File 'app/models/project.rb', line 720

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

#notified_usersObject

Returns the users that should be notified on project events


579
580
581
582
# File 'app/models/project.rb', line 579

def notified_users
  # TODO: User part should be extracted to User#notify_about?
  members.preload(:principal).select {|m| m.principal.present? && (m.mail_notification? || m.principal.mail_notification == 'all')}.collect {|m| m.principal}
end

#overdue?Boolean

Returns:

  • (Boolean)

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

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

#override_roles(role) ⇒ Object


221
222
223
224
225
226
227
228
229
# File 'app/models/project.rb', line 221

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

#principalsObject


231
232
233
# File 'app/models/project.rb', line 231

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

#principals_by_roleObject

Returns a hash of project users/groups grouped by role


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

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

#projectObject


616
617
618
# File 'app/models/project.rb', line 616

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.id = 1 OR (projects.lft > 1 AND projects.rgt < 10))"
project.project_condition(false) => "projects.id = 1"

312
313
314
315
316
# File 'app/models/project.rb', line 312

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

#recipientsObject

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


574
575
576
# File 'app/models/project.rb', line 574

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

#reload(*args) ⇒ Object


333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
# File 'app/models/project.rb', line 333

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
  base_reload(*args)
end

#reopenObject


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

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

#rolled_up_custom_fieldsObject

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


602
603
604
605
606
607
608
609
610
611
612
613
614
# File 'app/models/project.rb', line 602

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_statusesObject


456
457
458
459
460
461
462
463
464
465
# File 'app/models/project.rb', line 456

def rolled_up_statuses
  issue_status_ids = WorkflowTransition.
    where(:tracker_id => rolled_up_trackers.map(&: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


437
438
439
440
441
442
443
444
445
# File 'app/models/project.rb', line 437

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_scopeObject


447
448
449
450
451
452
453
454
# File 'app/models/project.rb', line 447

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_versionsObject

Returns a scope of the Versions on subprojects


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

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


791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
# File 'app/models/project.rb', line 791

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(attrs, user)
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


427
428
429
430
431
432
433
434
# File 'app/models/project.rb', line 427

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

#shared_versionsObject

Returns a scope of the Versions used by the project


487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
# File 'app/models/project.rb', line 487

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)


629
630
631
# File 'app/models/project.rb', line 629

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

#start_dateObject

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


650
651
652
653
654
655
656
657
# File 'app/models/project.rb', line 650

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_paramObject


354
355
356
357
358
359
360
361
# File 'app/models/project.rb', line 354

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_sObject


624
625
626
# File 'app/models/project.rb', line 624

def to_s
  name
end

#unarchiveObject

Unarchives the project and its archived ancestors


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

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


255
256
257
258
259
260
261
# File 'app/models/project.rb', line 255

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.


267
268
269
270
271
272
273
274
# File 'app/models/project.rb', line 267

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

#usersObject


235
236
237
# File 'app/models/project.rb', line 235

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

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

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

Returns:

  • (Boolean)

152
153
154
# File 'app/models/project.rb', line 152

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

#visible_custom_field_values(user = nil) ⇒ Object


906
907
908
909
910
911
# File 'app/models/project.rb', line 906

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