c228f12a-adf8-4d5f-8f93-74fc9e1a52a6

Committed 29 Oct 2024 06:13PM UTC coverage: 84.264% (+0.1%) from 84.116%

Build # c228f12a-adf8-4d5f-8f93-74fc9e1a52a6

Build Type

Pull #1014

circleci

Committed by

kelynch

Commit Message

Rubocop fixes

Pull Request Pull Request #1014: 977 add breadcrumbs model

Run Details

4 of 4 branches covered (100.0%)

25 of 25 new or added lines in 3 files covered. (100.0%)

7 existing lines in 1 file now uncovered.

2174 of 2580 relevant lines covered (84.26%)

300.98 hits per line

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

81.6

/app/controllers/projects_controller.rb

# frozen_string_literal: true
class ProjectsController < ApplicationController
  
  before_action :set_breadcrumbs

  def new
    add_breadcrumb("New Project Request")
    return build_new_project if current_user.eligible_sponsor?

    redirect_to root_path
  end

  def project_params
    params.dup
  end

  def create
    metadata_params = params.dup
    metadata_params[:status] = Project::PENDING_STATUS
    metadata_params[:created_by] = current_user.uid
    metadata_params[:created_on] = Time.current.in_time_zone("America/New_York").iso8601
    project_metadata = ProjectMetadata.new_from_params(metadata_params)

    build_new_project # calling private method to build a new project and set a class variable @project
    project.create!(initial_metadata: project_metadata, user: current_user)
    if project.metadata_model.project_id != nil
      begin
        mailer = TigerdataMailer.with(project_id: project.id)
        message_delivery = mailer.project_creation
        message_delivery.deliver_later

        redirect_to project_confirmation_path(project)
      rescue StandardError => mailer_error
        raise(TigerData::MailerError, mailer_error)
      end
    else
      render :new
    end
  rescue TigerData::MailerError => mailer_error
    logger_message = "Error encountered creating the project #{project.id} as user #{current_user.email}"
    Rails.logger.error(logger_message)
    honeybadger_context = {
      current_user_email: current_user.email,
      project_id: project.id,
      project_metadata: project.metadata
    }
    Honeybadger.notify(mailer_error, context: honeybadger_context)

    error_message = "We are sorry, while the project was successfully created, an error was encountered which prevents the delivery of an e-mail message confirming this. Please know that this error has been logged, and shall be reviewed by members of RDSS."
    flash[:notice] = error_message

    render :new
  rescue StandardError => error
    logger_message = if project.persisted?
                      "Error encountered creating the project #{project.id} as user #{current_user.email}"
                     else
                      "Error encountered creating the project #{metadata_params[:title]} as user #{current_user.email}"
                     end
    Rails.logger.error(logger_message)
    honeybadger_context = {
      current_user_email: current_user.email,
      project_id: project.id,
      project_metadata: project.metadata
    }
    Honeybadger.notify(error, context: honeybadger_context)

    error_message = "We are sorry, the project was not successfully created, and an error was encountered which prevents the delivery of an e-mail message confirming this. Please know that this error has been logged, and shall be reviewed by members of RDSS promptly."

    flash[:notice] = error_message
    render :new
  end

  def show
    add_breadcrumb(project.title, project_path)
    project
    @departments = project.departments.join(", ")
    @project_metadata = project.metadata_model

    @data_sponsor = User.find_by(uid: @project_metadata.data_sponsor)
    @data_manager = User.find_by(uid: @project_metadata.data_manager)

    read_only_uids = @project_metadata.ro_users
    data_read_only_users = read_only_uids.map { |uid| ReadOnlyUser.find_by(uid:) }.reject(&:blank?)

    read_write_uids = @project_metadata.rw_users
    data_read_write_users = read_write_uids.map { |uid| User.find_by(uid:) }.reject(&:blank?)

    unsorted_data_users = data_read_only_users + data_read_write_users
    sorted_data_users = unsorted_data_users.sort_by { |u| u.family_name || u.uid }
    @data_users = sorted_data_users.uniq { |u| u.uid }
    user_model_names = @data_users.map(&:display_name_safe)
    @data_user_names = user_model_names.join(", ")

    @provenance_events = project.provenance_events.where.not(event_type: ProvenanceEvent::STATUS_UPDATE_EVENT_TYPE)

    @project_eligible_to_edit = true if project.status == Project::APPROVED_STATUS && eligible_editor?

    @project_metadata = @project.metadata
    @project_id = @project_metadata[:project_id] || {}
    @storage_capacity = @project_metadata[:storage_capacity]
    @size = @storage_capacity[:size]
    @unit = @storage_capacity[:unit]

    @requested_size = @size[:requested]
    @requested_unit = @unit[:requested]

    @approved_size = @size[:approved]
    @approved_unit = @unit[:approved]

    @storage_expectations = @project_metadata[:storage_performance_expectations]
    @requested_storage_expectations = @storage_expectations[:requested]
    @approved_storage_expectations = @storage_expectations[:approved]

    @project_purpose = @project_metadata[:project_purpose]

    respond_to do |format|
      format.html do
        @project = ProjectShowPresenter.new(project)
      end
      format.json do
        render json: project.to_json
      end
      format.xml do
        render xml: project.to_xml
      end
    end
  end

  def edit
    add_breadcrumb(project.title, project_path)
    add_breadcrumb("Edit")
    project
    if project.metadata_model.status != Project::APPROVED_STATUS
      flash[:notice] = "Pending projects can not be edited."
      redirect_to project
    elsif project.metadata_model.status == Project::APPROVED_STATUS && !eligible_editor? #check if the current user is a sponsor or a manager
      flash[:notice] = "Only data sponsors and data managers can revise this project."
      redirect_to project
    end
  end

  def update
    @project = Project.find(params[:id])
    #Approve action
    if params.key?("mediaflux_id")
      @project.metadata_model.update_with_params(params, current_user)
      @project.approve!(mediaflux_id: params["mediaflux_id"],current_user:)
    end

    #Edit action
    if params.key?("title")
      @project.metadata_model.status = @project.metadata_model.status || Project::PENDING_STATUS
      @project.metadata_model.update_with_params(params, current_user)
    end

    # @todo ProjectMetadata should be refactored to implement ProjectMetadata.valid?(updated_metadata)
    if project.save and params.key?("mediaflux_id")
      redirect_to project_approval_received_path(@project)
    elsif project.save and params.key?("title")
      redirect_to project_revision_confirmation_path(@project)
    else
      render :edit
    end
  end

  def index
    @projects = Project.all
  end

  def confirmation; end
  def revision_confirmation; end

  def contents
    add_breadcrumb(project.title, project_path)
    add_breadcrumb("Contents", project_contents_path)
    project

    @storage_usage = project.storage_usage(session_id: current_user.mediaflux_session)
    @storage_capacity = project.storage_capacity(session_id: current_user.mediaflux_session)

    @num_files = project.asset_count(session_id: current_user.mediaflux_session)

    @file_list = project.file_list(session_id: current_user.mediaflux_session, size: 100)
    @files = @file_list[:files]
    @files.sort_by!(&:path)
  end

  def project_job_service
    @project_job_service ||= ProjectJobService.new(project:)
  end

  def list_contents
    project_job_service.list_contents_job(user: current_user)

    json_response = {
      message: "File list for \"#{project.title}\" is being generated in the background. A link to the downloadable file list will be available in the \"Recent Activity\" section of your dashboard when it is available. You may safely navigate away from this page or close this tab."
    }
    render json: json_response
  rescue => ex
    message = "Error producing document list (project id: #{project&.id}): #{ex.message}"
    Rails.logger.error(message)
    Honeybadger.notify(message)
    render json: { message: "Document list could not be generated." }
  end

  def file_list_download
    job_id = params[:job_id]
    user_request = FileInventoryRequest.where(job_id:job_id).first
    if user_request.nil?
      # TODO: handle error
      redirect_to "/"
    else
      filename = user_request.output_file
      send_data File.read(filename), type: "text/plain", filename: "filelist.csv", disposition: "attachment"
    end
  end

  def approve
    if current_user.eligible_sysadmin?
      add_breadcrumb(project.title, project_path)
      add_breadcrumb("Approval Settings", project_approve_path)
      add_breadcrumb("Edit")
      project
      @departments = project.departments.join(", ")
      @project_metadata = project.metadata
      sponsor_uid = @project_metadata[:data_sponsor]
      @data_sponsor = User.find_by(uid: sponsor_uid)
      @provenance_events = project.provenance_events.where.not(event_type: ProvenanceEvent::STATUS_UPDATE_EVENT_TYPE)

      @title = @project_metadata["title"]
    else redirect_to root_path
    end
  end

  def create_script
    project_id = params[:id]
    project = Project.find(project_id)
    service = MediafluxScriptFactory.new(project: project)
    respond_to do |format|
      format.json { render json: {script: service.aterm_script} }
    end
  end

  private

    def build_new_project
      @project ||= Project.new
    end

    def project
      @project ||= Project.find(params[:id])
    end

    def eligible_editor?
      return true if current_user.eligible_sponsor? or current_user.eligible_manager?
    end

    def shared_file_location(filename)
      raise "Shared location is not configured" if Rails.configuration.mediaflux["shared_files_location"].blank?
      location = Pathname.new(Rails.configuration.mediaflux["shared_files_location"])
      location.join(filename).to_s
    end

    def set_breadcrumbs
      add_breadcrumb("Dashboard","/")
    end
end

1	# frozen_string_literal: true
2	class ProjectsController < ApplicationController	1✔
3
4	before_action :set_breadcrumbs	1✔
5
6	def new	1✔
7	add_breadcrumb("New Project Request")	15✔
8	return build_new_project if current_user.eligible_sponsor?	15✔
9
10	redirect_to root_path	2✔
11	end
12
13	def project_params	1✔
14	params.dup	×
15	end
16
17	def create	1✔
18	metadata_params = params.dup	11✔
19	metadata_params[:status] = Project::PENDING_STATUS	11✔
20	metadata_params[:created_by] = current_user.uid	11✔
21	metadata_params[:created_on] = Time.current.in_time_zone("America/New_York").iso8601	11✔
22	project_metadata = ProjectMetadata.new_from_params(metadata_params)	11✔
23
24	build_new_project # calling private method to build a new project and set a class variable @project	11✔
25	project.create!(initial_metadata: project_metadata, user: current_user)	11✔
26	if project.metadata_model.project_id != nil	11✔
27	begin
28	mailer = TigerdataMailer.with(project_id: project.id)	11✔
29	message_delivery = mailer.project_creation	11✔
30	message_delivery.deliver_later	11✔
31
32	redirect_to project_confirmation_path(project)	9✔
33	rescue StandardError => mailer_error
34	raise(TigerData::MailerError, mailer_error)	3✔
35	end
36	else
37	render :new	×
38	end
39	rescue TigerData::MailerError => mailer_error
40	logger_message = "Error encountered creating the project #{project.id} as user #{current_user.email}"	3✔
41	Rails.logger.error(logger_message)	3✔
42	honeybadger_context = {
43	current_user_email: current_user.email,	3✔
44	project_id: project.id,
45	project_metadata: project.metadata
46	}
47	Honeybadger.notify(mailer_error, context: honeybadger_context)	3✔
48
49	error_message = "We are sorry, while the project was successfully created, an error was encountered which prevents the delivery of an e-mail message confirming this. Please know that this error has been logged, and shall be reviewed by members of RDSS."	3✔
50	flash[:notice] = error_message	3✔
51
52	render :new	3✔
53	rescue StandardError => error
54	logger_message = if project.persisted?	×
55	"Error encountered creating the project #{project.id} as user #{current_user.email}"	×
56	else
57	"Error encountered creating the project #{metadata_params[:title]} as user #{current_user.email}"	×
58	end
59	Rails.logger.error(logger_message)	×
60	honeybadger_context = {
61	current_user_email: current_user.email,	×
62	project_id: project.id,
63	project_metadata: project.metadata
64	}
65	Honeybadger.notify(error, context: honeybadger_context)	×
66
67	error_message = "We are sorry, the project was not successfully created, and an error was encountered which prevents the delivery of an e-mail message confirming this. Please know that this error has been logged, and shall be reviewed by members of RDSS promptly."	×
68
69	flash[:notice] = error_message	×
70	render :new	×
71	end
72
73	def show	1✔
74	add_breadcrumb(project.title, project_path)	30✔
75	project	30✔
76	@departments = project.departments.join(", ")	30✔
77	@project_metadata = project.metadata_model	30✔
78
79	@data_sponsor = User.find_by(uid: @project_metadata.data_sponsor)	30✔
80	@data_manager = User.find_by(uid: @project_metadata.data_manager)	30✔
81
82	read_only_uids = @project_metadata.ro_users	30✔
83	data_read_only_users = read_only_uids.map { \|uid\| ReadOnlyUser.find_by(uid:) }.reject(&:blank?)	49✔
84
85	read_write_uids = @project_metadata.rw_users	30✔
86	data_read_write_users = read_write_uids.map { \|uid\| User.find_by(uid:) }.reject(&:blank?)	49✔
87
88	unsorted_data_users = data_read_only_users + data_read_write_users	30✔
89	sorted_data_users = unsorted_data_users.sort_by { \|u\| u.family_name \|\| u.uid }	68✔
90	@data_users = sorted_data_users.uniq { \|u\| u.uid }	68✔
91	user_model_names = @data_users.map(&:display_name_safe)	30✔
92	@data_user_names = user_model_names.join(", ")	30✔
93
94	@provenance_events = project.provenance_events.where.not(event_type: ProvenanceEvent::STATUS_UPDATE_EVENT_TYPE)	30✔
95
96	@project_eligible_to_edit = true if project.status == Project::APPROVED_STATUS && eligible_editor?	30✔
97
98	@project_metadata = @project.metadata	30✔
99	@project_id = @project_metadata[:project_id] \|\| {}	30✔
100	@storage_capacity = @project_metadata[:storage_capacity]	30✔
101	@size = @storage_capacity[:size]	30✔
102	@unit = @storage_capacity[:unit]	30✔
103
104	@requested_size = @size[:requested]	30✔
105	@requested_unit = @unit[:requested]	30✔
106
107	@approved_size = @size[:approved]	30✔
108	@approved_unit = @unit[:approved]	30✔
109
110	@storage_expectations = @project_metadata[:storage_performance_expectations]	30✔
111	@requested_storage_expectations = @storage_expectations[:requested]	30✔
112	@approved_storage_expectations = @storage_expectations[:approved]	30✔
113
114	@project_purpose = @project_metadata[:project_purpose]	30✔
115
116	respond_to do \|format\|	30✔
117	format.html do	30✔
118	@project = ProjectShowPresenter.new(project)	28✔
119	end
120	format.json do	30✔
121	render json: project.to_json	1✔
122	end
123	format.xml do	30✔
124	render xml: project.to_xml	1✔
125	end
126	end
127	end
128
129	def edit	1✔
130	add_breadcrumb(project.title, project_path)	12✔
131	add_breadcrumb("Edit")	12✔
132	project	12✔
133	if project.metadata_model.status != Project::APPROVED_STATUS	12✔
134	flash[:notice] = "Pending projects can not be edited."	1✔
135	redirect_to project	1✔
136	elsif project.metadata_model.status == Project::APPROVED_STATUS && !eligible_editor? #check if the current user is a sponsor or a manager	11✔
137	flash[:notice] = "Only data sponsors and data managers can revise this project."	1✔
138	redirect_to project	1✔
139	end
140	end
141
142	def update	1✔
143	@project = Project.find(params[:id])	8✔
144	#Approve action
145	if params.key?("mediaflux_id")	8✔
146	@project.metadata_model.update_with_params(params, current_user)	2✔
147	@project.approve!(mediaflux_id: params["mediaflux_id"],current_user:)	2✔
148	end
149
150	#Edit action
151	if params.key?("title")	8✔
152	@project.metadata_model.status = @project.metadata_model.status \|\| Project::PENDING_STATUS	6✔
153	@project.metadata_model.update_with_params(params, current_user)	6✔
154	end
155
156	# @todo ProjectMetadata should be refactored to implement ProjectMetadata.valid?(updated_metadata)
157	if project.save and params.key?("mediaflux_id")	8✔
158	redirect_to project_approval_received_path(@project)	2✔
159	elsif project.save and params.key?("title")	6✔
160	redirect_to project_revision_confirmation_path(@project)	6✔
161	else
UNCOV 162	render :edit	×
163	end
164	end
165
166	def index	1✔
167	@projects = Project.all	2✔
168	end
169
170	def confirmation; end	1✔
171	def revision_confirmation; end	1✔
172
173	def contents	1✔
174	add_breadcrumb(project.title, project_path)	8✔
175	add_breadcrumb("Contents", project_contents_path)	8✔
176	project	8✔
177
178	@storage_usage = project.storage_usage(session_id: current_user.mediaflux_session)	8✔
179	@storage_capacity = project.storage_capacity(session_id: current_user.mediaflux_session)	7✔
180
181	@num_files = project.asset_count(session_id: current_user.mediaflux_session)	7✔
182
183	@file_list = project.file_list(session_id: current_user.mediaflux_session, size: 100)	7✔
184	@files = @file_list[:files]	7✔
185	@files.sort_by!(&:path)	7✔
186	end
187
188	def project_job_service	1✔
189	@project_job_service \|\|= ProjectJobService.new(project:)	1✔
190	end
191
192	def list_contents	1✔
193	project_job_service.list_contents_job(user: current_user)	1✔
194
195	json_response = {
196	message: "File list for \"#{project.title}\" is being generated in the background. A link to the downloadable file list will be available in the \"Recent Activity\" section of your dashboard when it is available. You may safely navigate away from this page or close this tab."	1✔
197	}
198	render json: json_response	1✔
199	rescue => ex
UNCOV 200	message = "Error producing document list (project id: #{project&.id}): #{ex.message}"	×
201	Rails.logger.error(message)	×
202	Honeybadger.notify(message)	×
203	render json: { message: "Document list could not be generated." }	×
204	end
205
206	def file_list_download	1✔
UNCOV 207	job_id = params[:job_id]	×
208	user_request = FileInventoryRequest.where(job_id:job_id).first	×
209	if user_request.nil?	×
210	# TODO: handle error
UNCOV 211	redirect_to "/"	×
212	else
UNCOV 213	filename = user_request.output_file	×
214	send_data File.read(filename), type: "text/plain", filename: "filelist.csv", disposition: "attachment"	×
215	end
216	end
217
218	def approve	1✔
219	if current_user.eligible_sysadmin?	7✔
220	add_breadcrumb(project.title, project_path)	4✔
221	add_breadcrumb("Approval Settings", project_approve_path)	4✔
222	add_breadcrumb("Edit")	4✔
223	project	4✔
224	@departments = project.departments.join(", ")	4✔
225	@project_metadata = project.metadata	4✔
226	sponsor_uid = @project_metadata[:data_sponsor]	4✔
227	@data_sponsor = User.find_by(uid: sponsor_uid)	4✔
228	@provenance_events = project.provenance_events.where.not(event_type: ProvenanceEvent::STATUS_UPDATE_EVENT_TYPE)	4✔
229
230	@title = @project_metadata["title"]	4✔
231	else redirect_to root_path	3✔
232	end
233	end
234
235	def create_script	1✔
UNCOV 236	project_id = params[:id]	×
237	project = Project.find(project_id)	×
238	service = MediafluxScriptFactory.new(project: project)	×
239	respond_to do \|format\|	×
240	format.json { render json: {script: service.aterm_script} }	×
241	end
242	end
243
244	private	1✔
245
246	def build_new_project	1✔
247	@project \|\|= Project.new	24✔
248	end
249
250	def project	1✔
251	@project \|\|= Project.find(params[:id])	391✔
252	end
253
254	def eligible_editor?	1✔
255	return true if current_user.eligible_sponsor? or current_user.eligible_manager?	21✔
256	end
257
258	def shared_file_location(filename)	1✔
UNCOV 259	raise "Shared location is not configured" if Rails.configuration.mediaflux["shared_files_location"].blank?	×
260	location = Pathname.new(Rails.configuration.mediaflux["shared_files_location"])	×
261	location.join(filename).to_s	×
262	end
263
264	def set_breadcrumbs	1✔
265	add_breadcrumb("Dashboard","/")	105✔
266	end
267	end

pulibrary / tigerdata-app / c228f12a-adf8-4d5f-8f93-74fc9e1a52a6

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