2757569b-a064-4cee-9331-aad3bf7cbc86

Committed 12 Sep 2024 05:16PM UTC coverage: 85.949% (-4.3%) from 90.227%

Build # 2757569b-a064-4cee-9331-aad3bf7cbc86

Build Type

push

circleci

Committed by

web-flow

Commit Message

Use circleci orb to report coverage (#918)

Run Details

4 of 4 branches covered (100.0%)

2147 of 2498 relevant lines covered (85.95%)

295.77 hits per line

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

80.0

/app/controllers/projects_controller.rb

# frozen_string_literal: true
class ProjectsController < ApplicationController
  def new
    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
    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
      format.json do
        render json: project.to_json
      end
      format.xml do
        render xml: project.to_xml
      end
    end
  end

  def 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
    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?
      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
end

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

pulibrary / tigerdata-app / 2757569b-a064-4cee-9331-aad3bf7cbc86

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