a05ca78b-80f9-4346-b1cc-766060b29f7a

# frozen_string_literal: true
class ProjectsController < ApplicationController
  def new
    if current_user.eligible_sponsor?
    new_project
    else redirect_to root_path
    end
  end

  def project_params
    values = params.dup
  end

  def create
    new_project
    project_metadata = ProjectMetadata.new( current_user:, project: new_project)
    new_project_params = params.dup
    metadata_params = new_project_params.merge({
      status: Project::PENDING_STATUS
    })
    project_metadata.create(params: metadata_params)
    if new_project.save
      mailer = TigerdataMailer.with(project_id: @project.id)
      message_delivery = mailer.project_creation
      message_delivery.deliver_later

      redirect_to project_confirmation_path(@project)
    else
      render :new
    end
  rescue RedisClient::CannotConnectError => redis_connect_error
    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."

    Rails.logger.error(error_message)
    Honeybadger.notify(redis_connect_error, context: { current_user_email: current_user.email, project_id: @project.id })

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

pulibrary / tigerdata-app / a05ca78b-80f9-4346-b1cc-766060b29f7a

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