491a775e-db3a-4215-bc5e-817569fa5f52

Committed 03 Oct 2024 05:13PM UTC coverage: 96.089% (-0.09%) from 96.176%

Build # 491a775e-db3a-4215-bc5e-817569fa5f52

Build Type

Pull #1957

circleci

Committed by

leefaisonr

Commit Message

rubocop and enable more than 5 params

Pull Request Pull Request #1957: Fixed deprecation warning for fixture_paths

Run Details

24 of 25 new or added lines in 8 files covered. (96.0%)

3 existing lines in 1 file now uncovered.

3317 of 3452 relevant lines covered (96.09%)

206.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.19

/app/models/group.rb

# frozen_string_literal: true

# rubocop:disable Metrics/ClassLength
class Group < ApplicationRecord
  resourcify

  # GroupOptions model extensible options set for Groups and Users
  has_many :group_options, dependent: :destroy, class_name: "GroupOption"
  has_many :group_messaging_options, -> { where(option_type: GroupOption::EMAIL_MESSAGES) }, class_name: "GroupOption", dependent: :destroy

  has_many :users_with_options, through: :group_options, source: :user
  has_many :users_with_messaging, through: :group_messaging_options, source: :user

  validate do |group|
    if group.title.blank?
      group.errors.add :base, "Title cannot be empty"
    end
  end

  def default_admins_list
    return [] if code.blank?
    key = code.downcase.to_sym
    Rails.configuration.group_defaults.dig(key, :admin) || []
  end

  def default_submitters_list
    key = code.downcase.to_sym
    Rails.configuration.group_defaults.dig(key, :submit) || []
  end

  def super_administrators
    User.with_role(:super_admin)
  end

  def datasets
    Work.where(group_id: id)
  end

  def submitters
    User.with_role(:submitter, self)
  end

  # Permit a User to receive notification messages for members of this Group
  # @param user [User]
  def enable_messages_for(user:, subcommunity: nil)
    raise(ArgumentError, "User #{user.uid} is not an administrator or submitter for this group #{title}") unless user.can_admin?(self) || user.can_submit?(self)
    group = GroupOption.find_or_initialize_by(option_type: GroupOption::EMAIL_MESSAGES, user:, group: self, subcommunity:)
    group.enabled = true
    group.save
  end

  # Disable a User from receiving notification messages for members of this Group
  # @param user [User]
  def disable_messages_for(user:, subcommunity: nil)
    raise(ArgumentError, "User #{user.uid} is not an administrator or submitter for this group #{title}") unless user.can_admin?(self) || user.can_submit?(self)
    group = GroupOption.find_or_initialize_by(option_type: GroupOption::EMAIL_MESSAGES, user:, group: self, subcommunity:)
    group.enabled = false
    group.save
  end

  # Returns true if a given user has notification e-mails enabled for this Group
  # @param user [User]
  # @return [Boolean]
  def messages_enabled_for?(user:, subcommunity: nil)
    group_option = group_messaging_options.find_by(user:, group: self, subcommunity:)
    group_option ||= GroupOption.new(enabled: true)
    group_option.enabled
  end

  def self.create_defaults
    return if where(code: "RD").count > 0
    Rails.logger.info "Creating default Groups"
    create(title: "Princeton Research Data Service (PRDS)", code: "RD")
    create(title: "Princeton Plasma Physics Lab (PPPL)", code: "PPPL")
  end

  # Returns the default group.
  # Used when we don't have anything else to determine a more specific Group for a user.
  def self.default
    create_defaults
    research_data
  end

  # Returns the default group for a given department number.
  # Reference: https://docs.google.com/spreadsheets/d/1_Elxs3Ex-2wCbbKUzD4ii3k16zx36sYf/edit#gid=1484576831
  def self.default_for_department(department_number)
    if department_number.present? && department_number >= "31000" && department_number <= "31027"
      plasma_laboratory
    else
      default
    end
  end

  def self.research_data
    create_defaults
    where(code: "RD").first
  end

  def self.plasma_laboratory
    create_defaults
    where(code: "PPPL").first
  end

  def administrators
    User.with_role(:group_admin, self)
  end

  ##
  # The current user adds a new admin user to a group.
  # For use in the UI - we need to check whether the current_user
  # has the right permissions to add someone as an admin_user.
  # @param [User] current_user - the currently logged in user
  # @param [User] admin_user - the user who will be granted admin rights on this group
  def add_administrator(current_user, admin_user)
    if current_user.has_role?(:super_admin) || current_user.has_role?(:group_admin, self)
      if admin_user.has_role? :group_admin, self
        errors.add(:admin, "User has already been added")
      else
        errors.delete(:admin)
        admin_user.add_role :group_admin, self
      end
    else
      errors.add(:admin, "Unauthorized")
    end
  end

  def add_submitter(current_user, additional_user)
    if current_user.has_role?(:super_admin) || current_user.has_role?(:group_admin, self)
      return if (self == additional_user.default_group) && additional_user.just_created

      if additional_user.has_role? :submitter, self
        errors.add(:submitter, "User has already been added")
      else
        errors.delete(:submitter)
        additional_user.add_role :submitter, self
      end
    else
      errors.add(:submitter, "Unauthorized")
    end
  end

  def delete_permission(current_user, removed_user)
    if current_user.has_role?(:super_admin) || current_user.has_role?(:group_admin, self)
      if removed_user.nil?
        errors.add(:delete_permission, "User was not found")
      elsif removed_user == current_user
        errors.add(:delete_permission, "Cannot remove yourself from a group. Contact a super-admin for help.")
      else
        errors.delete(:delete_permission)
        removed_user.remove_role :group_admin, self
        removed_user.remove_role :submitter, self
      end
    else
      errors.add(:delete_permission, "Unauthorized")
    end
  end

  def communities
    if code == "PPPL"
      ["Princeton Plasma Physics Laboratory"]
    else
      ["Princeton Neuroscience Institute", "Department of Geosciences", "Mechanical and Aerospace Engineering",
       "Astrophysical Sciences", "Civil and Environmental Engineering", "Chemical and Biological Engineering",
       "Digital Humanities", "Music and Arts", "Princeton School of Public and International Affairs"].sort
    end
  end

  # rubocop:disable Metrics/MethodLength
  def subcommunities
    values = []
    if code == "PPPL"
      values << "Spherical Torus"
      values << "Advanced Projects"
      values << "ITER and Tokamaks"
      values << "Theory"
      values << "NSTX-U"
      values << "NSTX"
      values << "Discovery Plasma Science"
      values << "Theory and Computation"
      values << "Stellarators"
      values << "PPPL Collaborations"
      values << "MAST-U"
      values << "Other Projects"
      values << "System Studies"
      values << "Applied Materials and Sustainability Sciences"
      values << "Computational Science"
      values << "DIII-D"
      values << "Tokamak Experimental Sciences"

    end
    values.sort
  end
  # rubocop:enable Metrics/MethodLength

  def publisher
    if code == "PPPL"
      "Princeton Plasma Physics Laboratory, Princeton University"
    else
      "Princeton University"
    end
  end

  def default_community
    communities.first if code == "PPPL"
  end

  def default_user(uid)
    user = User.find_by(uid:)
    return user if user.present?

    begin
      user = User.new(uid:, default_group_id: id)
      user.save!
      user
    rescue ActiveRecord::RecordNotUnique => unique_error
      # If adding a submitter to an existing group
      Rails.logger.error("Failed to created a new user for #{self}: #{unique_error}")
      user = User.new(uid:)
      user.default_group_id = id
      user.save!
      user
    end
  end
end
# rubocop:enable Metrics/ClassLength

1	# frozen_string_literal: true
2
3	# rubocop:disable Metrics/ClassLength
4	class Group < ApplicationRecord	1✔
5	resourcify	1✔
6
7	# GroupOptions model extensible options set for Groups and Users
8	has_many :group_options, dependent: :destroy, class_name: "GroupOption"	1✔
9	has_many :group_messaging_options, -> { where(option_type: GroupOption::EMAIL_MESSAGES) }, class_name: "GroupOption", dependent: :destroy	473✔
10
11	has_many :users_with_options, through: :group_options, source: :user	1✔
12	has_many :users_with_messaging, through: :group_messaging_options, source: :user	1✔
13
14	validate do \|group\|	1✔
15	if group.title.blank?	1,544✔
16	group.errors.add :base, "Title cannot be empty"	2✔
17	end
18	end
19
20	def default_admins_list	1✔
21	return [] if code.blank?	2✔
22	key = code.downcase.to_sym	2✔
23	Rails.configuration.group_defaults.dig(key, :admin) \|\| []	2✔
24	end
25
26	def default_submitters_list	1✔
27	key = code.downcase.to_sym	2✔
28	Rails.configuration.group_defaults.dig(key, :submit) \|\| []	2✔
29	end
30
31	def super_administrators	1✔
32	User.with_role(:super_admin)	9✔
33	end
34
35	def datasets	1✔
36	Work.where(group_id: id)	3✔
37	end
38
39	def submitters	1✔
40	User.with_role(:submitter, self)	9✔
41	end
42
43	# Permit a User to receive notification messages for members of this Group
44	# @param user [User]
45	def enable_messages_for(user:, subcommunity: nil)	1✔
46	raise(ArgumentError, "User #{user.uid} is not an administrator or submitter for this group #{title}") unless user.can_admin?(self) \|\| user.can_submit?(self)	1,331✔
47	group = GroupOption.find_or_initialize_by(option_type: GroupOption::EMAIL_MESSAGES, user:, group: self, subcommunity:)	1,331✔
48	group.enabled = true	1,331✔
49	group.save	1,331✔
50	end
51
52	# Disable a User from receiving notification messages for members of this Group
53	# @param user [User]
54	def disable_messages_for(user:, subcommunity: nil)	1✔
55	raise(ArgumentError, "User #{user.uid} is not an administrator or submitter for this group #{title}") unless user.can_admin?(self) \|\| user.can_submit?(self)	106✔
56	group = GroupOption.find_or_initialize_by(option_type: GroupOption::EMAIL_MESSAGES, user:, group: self, subcommunity:)	105✔
57	group.enabled = false	105✔
58	group.save	105✔
59	end
60
61	# Returns true if a given user has notification e-mails enabled for this Group
62	# @param user [User]
63	# @return [Boolean]
64	def messages_enabled_for?(user:, subcommunity: nil)	1✔
65	group_option = group_messaging_options.find_by(user:, group: self, subcommunity:)	377✔
66	group_option \|\|= GroupOption.new(enabled: true)	377✔
67	group_option.enabled	377✔
68	end
69
70	def self.create_defaults	1✔
71	return if where(code: "RD").count > 0	8,505✔
72	Rails.logger.info "Creating default Groups"	759✔
73	create(title: "Princeton Research Data Service (PRDS)", code: "RD")	759✔
74	create(title: "Princeton Plasma Physics Lab (PPPL)", code: "PPPL")	759✔
75	end
76
77	# Returns the default group.
78	# Used when we don't have anything else to determine a more specific Group for a user.
79	def self.default	1✔
80	create_defaults	3,369✔
81	research_data	3,369✔
82	end
83
84	# Returns the default group for a given department number.
85	# Reference: https://docs.google.com/spreadsheets/d/1_Elxs3Ex-2wCbbKUzD4ii3k16zx36sYf/edit#gid=1484576831
86	def self.default_for_department(department_number)	1✔
87	if department_number.present? && department_number >= "31000" && department_number <= "31027"	293✔
88	plasma_laboratory	57✔
89	else
90	default	236✔
91	end
92	end
93
94	def self.research_data	1✔
95	create_defaults	4,549✔
96	where(code: "RD").first	4,549✔
97	end
98
99	def self.plasma_laboratory	1✔
100	create_defaults	403✔
101	where(code: "PPPL").first	403✔
102	end
103
104	def administrators	1✔
105	User.with_role(:group_admin, self)	289✔
106	end
107
108	##
109	# The current user adds a new admin user to a group.
110	# For use in the UI - we need to check whether the current_user
111	# has the right permissions to add someone as an admin_user.
112	# @param [User] current_user - the currently logged in user
113	# @param [User] admin_user - the user who will be granted admin rights on this group
114	def add_administrator(current_user, admin_user)	1✔
115	if current_user.has_role?(:super_admin) \|\| current_user.has_role?(:group_admin, self)	5✔
116	if admin_user.has_role? :group_admin, self	4✔
117	errors.add(:admin, "User has already been added")	1✔
118	else
119	errors.delete(:admin)	3✔
120	admin_user.add_role :group_admin, self	3✔
121	end
122	else
123	errors.add(:admin, "Unauthorized")	1✔
124	end
125	end
126
127	def add_submitter(current_user, additional_user)	1✔
128	if current_user.has_role?(:super_admin) \|\| current_user.has_role?(:group_admin, self)	17✔
129	return if (self == additional_user.default_group) && additional_user.just_created	16✔
130
131	if additional_user.has_role? :submitter, self	13✔
132	errors.add(:submitter, "User has already been added")	3✔
133	else
134	errors.delete(:submitter)	10✔
135	additional_user.add_role :submitter, self	10✔
136	end
137	else
138	errors.add(:submitter, "Unauthorized")	1✔
139	end
140	end
141
142	def delete_permission(current_user, removed_user)	1✔
143	if current_user.has_role?(:super_admin) \|\| current_user.has_role?(:group_admin, self)	5✔
144	if removed_user.nil?	4✔
145	errors.add(:delete_permission, "User was not found")	1✔
146	elsif removed_user == current_user	3✔
147	errors.add(:delete_permission, "Cannot remove yourself from a group. Contact a super-admin for help.")	1✔
148	else
149	errors.delete(:delete_permission)	2✔
150	removed_user.remove_role :group_admin, self	2✔
151	removed_user.remove_role :submitter, self	2✔
152	end
153	else
154	errors.add(:delete_permission, "Unauthorized")	1✔
155	end
156	end
157
158	def communities	1✔
159	if code == "PPPL"	172✔
160	["Princeton Plasma Physics Laboratory"]	12✔
161	else
162	["Princeton Neuroscience Institute", "Department of Geosciences", "Mechanical and Aerospace Engineering",	160✔
163	"Astrophysical Sciences", "Civil and Environmental Engineering", "Chemical and Biological Engineering",
164	"Digital Humanities", "Music and Arts", "Princeton School of Public and International Affairs"].sort
165	end
166	end
167
168	# rubocop:disable Metrics/MethodLength
169	def subcommunities	1✔
170	values = []	116✔
171	if code == "PPPL"	116✔
172	values << "Spherical Torus"	22✔
173	values << "Advanced Projects"	22✔
174	values << "ITER and Tokamaks"	22✔
175	values << "Theory"	22✔
176	values << "NSTX-U"	22✔
177	values << "NSTX"	22✔
178	values << "Discovery Plasma Science"	22✔
179	values << "Theory and Computation"	22✔
180	values << "Stellarators"	22✔
181	values << "PPPL Collaborations"	22✔
182	values << "MAST-U"	22✔
183	values << "Other Projects"	22✔
184	values << "System Studies"	22✔
185	values << "Applied Materials and Sustainability Sciences"	22✔
186	values << "Computational Science"	22✔
187	values << "DIII-D"	22✔
188	values << "Tokamak Experimental Sciences"	22✔
189
190	end
191	values.sort	116✔
192	end
193	# rubocop:enable Metrics/MethodLength
194
195	def publisher	1✔
196	if code == "PPPL"	97✔
197	"Princeton Plasma Physics Laboratory, Princeton University"	10✔
198	else
199	"Princeton University"	87✔
200	end
201	end
202
203	def default_community	1✔
NEW 204	communities.first if code == "PPPL"	×
205	end
206
207	def default_user(uid)	1✔
208	user = User.find_by(uid:)	12✔
209	return user if user.present?	12✔
210
211	begin
212	user = User.new(uid:, default_group_id: id)	6✔
213	user.save!	5✔
214	user	5✔
215	rescue ActiveRecord::RecordNotUnique => unique_error	1✔
216	# If adding a submitter to an existing group
217	Rails.logger.error("Failed to created a new user for #{self}: #{unique_error}")	1✔
218	user = User.new(uid:)	1✔
219	user.default_group_id = id	1✔
220	user.save!	1✔
221	user	1✔
222	end
223	end
224	end
225	# rubocop:enable Metrics/ClassLength

pulibrary / pdc_describe / 491a775e-db3a-4215-bc5e-817569fa5f52

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous