409aa1d2-85be-4874-83c2-00be892c1f92

Committed 01 Mar 2024 06:44PM UTC coverage: 89.768% (-0.4%) from 90.201%

Build # 409aa1d2-85be-4874-83c2-00be892c1f92

Build Type

push

circleci

Committed by

jrgriffiniii

Commit Message

wip

Run Details

21 of 28 new or added lines in 2 files covered. (75.0%)

2 existing lines in 1 file now uncovered.

1395 of 1554 relevant lines covered (89.77%)

13.4 hits per line

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

83.46

/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
    project_metadata = ProjectMetadata.new( current_user:, project: build_new_project)
    new_project_params = project_params
    metadata_params = new_project_params.merge({
      status: Project::PENDING_STATUS
    })
    project_metadata.create(params: metadata_params)
    if project.save
      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 = {
      context: {
        current_user_email: current_user.email,
        project_id: @project.id,
        project_metadata: metadata_params
      }
    }
    Honeybadger.notify(mailer_error, **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 = {
      context: {
        current_user_email: current_user.email,
        project_id: @project.id,
        project_metadata: metadata_params
      }
    }
    Honeybadger.notify(error, **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

    sponsor_uid = @project_metadata[:data_sponsor]
    @data_sponsor = User.find_by(uid: sponsor_uid)

    manager_uid = @project_metadata[:data_manager]
    @data_manager = User.find_by(uid: manager_uid)

    read_only_uids = @project_metadata.fetch(:data_user_read_only, [])
    data_read_only_users = read_only_uids.map { |uid| ReadOnlyUser.find_by(uid:) }.reject(&:blank?)

    read_write_uids = @project_metadata.fetch(:data_user_read_write, [])
    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(", ")

    @submission_events = project.provenance_events.where(event_type: ProvenanceEvent::SUBMISSION_EVENT_TYPE)
    @project_status = project.metadata[:status]

    @approve_status = Project::APPROVE_STATUS
    @eligible_editor = eligible_editor?
    @project_eligible_to_edit = true if @project_status == @approve_status && eligible_editor?

    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[:status] != Project::APPROVE_STATUS
      flash[:notice] = "Pending projects can not be edited."
      redirect_to project
    elsif project.metadata[:status] == Project::APPROVE_STATUS && !eligible_editor? #check if the current user is a sponsor of manager
      flash[:notice] = "Only data sponsors and data managers can revise this project."
      redirect_to project
    end
  end

  def update
    project
    #Approve action
    if params.key?("mediaflux_id")
      project.mediaflux_id = params["mediaflux_id"]
      project.metadata_json["status"] = Project::APPROVE_STATUS
      params.delete("mediaflux_id")
    end

    #Edit action
    if params.key?("title")
      project_metadata = ProjectMetadata.new(project: project, current_user:)
      project_params = params.dup
      metadata_params = project_params.merge({
        status: project.metadata[:status]
      })
      project.metadata = project_metadata.update_metadata(params: metadata_params)
    end

    # @todo ProjectMetadata should be refactored to implement ProjectMetadata.valid?(updated_metadata)
    if project.save
      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."
    }
    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_job = UserJob.where(job_id:job_id).first
    if user_job.nil?
      # TODO: handle error
      redirect_to "/"
    else
      filename = "#{Dir.pwd}/public/#{job_id}.csv"
      send_data File.read(filename), type: "text/plain", filename: "filelist.csv", disposition: "attachment"
    end
  end

  def approve
    if current_user.eligible_sysadmin?
      project
      @project_metadata = project.metadata
      @title = @project_metadata["title"]
    else redirect_to root_path
    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
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?	12✔
5
6	redirect_to root_path	1✔
7	end
8
9	def project_params	1✔
10	params.dup	10✔
11	end
12
13	def create	1✔
14	project_metadata = ProjectMetadata.new( current_user:, project: build_new_project)	10✔
15	new_project_params = project_params	10✔
16	metadata_params = new_project_params.merge({	10✔
17	status: Project::PENDING_STATUS
18	})
19	project_metadata.create(params: metadata_params)	10✔
20	if project.save	10✔
21	begin
22	mailer = TigerdataMailer.with(project_id: project.id)	9✔
23	message_delivery = mailer.project_creation	9✔
24	message_delivery.deliver_later	9✔
25
26	redirect_to project_confirmation_path(project)	7✔
27	rescue StandardError => mailer_error	2✔
28	raise(TigerData::MailerError, mailer_error)	2✔
29	end
30	else
31	render :new	1✔
32	end
33	rescue TigerData::MailerError => mailer_error
34	logger_message = "Error encountered creating the project #{project.id} as user #{current_user.email}"	2✔
35	Rails.logger.error(logger_message)	2✔
36	honeybadger_context = {
37	context: {	2✔
38	current_user_email: current_user.email,
39	project_id: @project.id,
40	project_metadata: metadata_params
41	}
42	}
43	Honeybadger.notify(mailer_error, **honeybadger_context)	2✔
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."	2✔
46	flash[:notice] = error_message	2✔
47
48	render :new	2✔
49	rescue StandardError => error
NEW 50	logger_message = if project.persisted?	×
NEW 51	"Error encountered creating the project #{project.id} as user #{current_user.email}"	×
52	else
NEW 53	"Error encountered creating the project #{metadata_params[:title]} as user #{current_user.email}"	×
54	end
NEW 55	Rails.logger.error(logger_message)	×
56	honeybadger_context = {
NEW 57	context: {	×
58	current_user_email: current_user.email,
59	project_id: @project.id,
60	project_metadata: metadata_params
61	}
62	}
NEW 63	Honeybadger.notify(error, **honeybadger_context)	×
64
NEW 65	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."	×
66
UNCOV 67	flash[:notice] = error_message	×
UNCOV 68	render :new	×
69	end
70
71	def show	1✔
72	project	20✔
73	@departments = project.departments.join(", ")	20✔
74	@project_metadata = project.metadata	20✔
75
76	sponsor_uid = @project_metadata[:data_sponsor]	20✔
77	@data_sponsor = User.find_by(uid: sponsor_uid)	20✔
78
79	manager_uid = @project_metadata[:data_manager]	20✔
80	@data_manager = User.find_by(uid: manager_uid)	20✔
81
82	read_only_uids = @project_metadata.fetch(:data_user_read_only, [])	20✔
83	data_read_only_users = read_only_uids.map { \|uid\| ReadOnlyUser.find_by(uid:) }.reject(&:blank?)	34✔
84
85	read_write_uids = @project_metadata.fetch(:data_user_read_write, [])	20✔
86	data_read_write_users = read_write_uids.map { \|uid\| User.find_by(uid:) }.reject(&:blank?)	34✔
87
88	unsorted_data_users = data_read_only_users + data_read_write_users	20✔
89	sorted_data_users = unsorted_data_users.sort_by { \|u\| u.family_name \|\| u.uid }	48✔
90	@data_users = sorted_data_users.uniq { \|u\| u.uid }	48✔
91	user_model_names = @data_users.map(&:display_name_safe)	20✔
92	@data_user_names = user_model_names.join(", ")	20✔
93
94	@submission_events = project.provenance_events.where(event_type: ProvenanceEvent::SUBMISSION_EVENT_TYPE)	20✔
95	@project_status = project.metadata[:status]	20✔
96
97	@approve_status = Project::APPROVE_STATUS	20✔
98	@eligible_editor = eligible_editor?	20✔
99	@project_eligible_to_edit = true if @project_status == @approve_status && eligible_editor?	20✔
100
101	respond_to do \|format\|	20✔
102	format.html	20✔
103	format.json do	20✔
104	render json: project.to_json	1✔
105	end
106	format.xml do	20✔
107	render xml: project.to_xml	1✔
108	end
109	end
110	end
111
112	def edit	1✔
113	project	10✔
114	if project.metadata[:status] != Project::APPROVE_STATUS	10✔
115	flash[:notice] = "Pending projects can not be edited."	1✔
116	redirect_to project	1✔
117	elsif project.metadata[:status] == Project::APPROVE_STATUS && !eligible_editor? #check if the current user is a sponsor of manager	9✔
118	flash[:notice] = "Only data sponsors and data managers can revise this project."	1✔
119	redirect_to project	1✔
120	end
121	end
122
123	def update	1✔
124	project	6✔
125	#Approve action
126	if params.key?("mediaflux_id")	6✔
127	project.mediaflux_id = params["mediaflux_id"]	1✔
128	project.metadata_json["status"] = Project::APPROVE_STATUS	1✔
129	params.delete("mediaflux_id")	1✔
130	end
131
132	#Edit action
133	if params.key?("title")	6✔
134	project_metadata = ProjectMetadata.new(project: project, current_user:)	5✔
135	project_params = params.dup	5✔
136	metadata_params = project_params.merge({	5✔
137	status: project.metadata[:status]
138	})
139	project.metadata = project_metadata.update_metadata(params: metadata_params)	5✔
140	end
141
142	# @todo ProjectMetadata should be refactored to implement ProjectMetadata.valid?(updated_metadata)
143	if project.save	6✔
144	redirect_to project_revision_confirmation_path(@project)	6✔
145	else
146	render :edit	×
147	end
148	end
149
150	def index	1✔
151	@projects = Project.all	1✔
152	end
153
154	def confirmation; end	1✔
155	def revision_confirmation; end	1✔
156
157	def contents	1✔
158	project	2✔
159
160	@storage_usage = project.storage_usage(session_id: current_user.mediaflux_session)	2✔
161	@storage_capacity = project.storage_capacity(session_id: current_user.mediaflux_session)	2✔
162
163	@num_files = project.asset_count(session_id: current_user.mediaflux_session)	2✔
164
165	@file_list = project.file_list(session_id: current_user.mediaflux_session, size: 100)	2✔
166	@files = @file_list[:files]	2✔
167	@files.sort_by!(&:path)	2✔
168	end
169
170	def project_job_service	1✔
171	@project_job_service \|\|= ProjectJobService.new(project:)	1✔
172	end
173
174	def list_contents	1✔
175	project_job_service.list_contents_job(user: current_user)	1✔
176
177	json_response = {
178	message: "File list for \"#{project.title}\" is being generated in the background."	1✔
179	}
180	render json: json_response	1✔
181	rescue => ex
182	message = "Error producing document list (project id: #{project&.id}): #{ex.message}"	×
183	Rails.logger.error(message)	×
184	Honeybadger.notify(message)	×
185	render json: { message: "Document list could not be generated." }	×
186	end
187
188	def file_list_download	1✔
189	job_id = params[:job_id]	×
190	user_job = UserJob.where(job_id:job_id).first	×
191	if user_job.nil?	×
192	# TODO: handle error
193	redirect_to "/"	×
194	else
195	filename = "#{Dir.pwd}/public/#{job_id}.csv"	×
196	send_data File.read(filename), type: "text/plain", filename: "filelist.csv", disposition: "attachment"	×
197	end
198	end
199
200	def approve	1✔
201	if current_user.eligible_sysadmin?	1✔
202	project	1✔
203	@project_metadata = project.metadata	1✔
204	@title = @project_metadata["title"]	1✔
205	else redirect_to root_path	×
206	end
207	end
208
209	private	1✔
210
211	def build_new_project	1✔
212	@project \|\|= Project.new	21✔
213	end
214
215	def project	1✔
216	@project \|\|= Project.find(params[:id])	204✔
217	end
218
219	def eligible_editor?	1✔
220	return true if current_user.eligible_sponsor? or current_user.eligible_manager?	35✔
221	end
222	end

pulibrary / tigerdata-app / 409aa1d2-85be-4874-83c2-00be892c1f92

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