a7a7c677-70ce-4fb7-93a9-85b7a17ef43a

Committed 10 Dec 2024 07:51PM UTC coverage: 83.95% (-0.3%) from 84.203%

Build # a7a7c677-70ce-4fb7-93a9-85b7a17ef43a

Build Type

Pull #1097

circleci

Committed by

carolyncole

Commit Message

Adding a tble to display the contents of a project

Pull Request Pull Request #1097: Adding a table to display the contents of a project

Run Details

4 of 4 branches covered (100.0%)

2 of 9 new or added lines in 2 files covered. (22.22%)

12 existing lines in 4 files now uncovered.

2223 of 2648 relevant lines covered (83.95%)

332.31 hits per line

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

98.81

/app/models/project.rb

# frozen_string_literal: true
class Project < ApplicationRecord
  validates_with ProjectValidator
  has_many :provenance_events, dependent: :destroy
  before_save do |project|
    # Ensure that the metadata JSONB postgres field is persisted properly
    project.metadata = project.metadata_model
  end

  # Valid project status described in ADR 7
  # See `architecture-decisions/0007-valid-project-statuses.md`
  PENDING_STATUS = "pending"
  APPROVED_STATUS = "approved"
  ACTIVE_STATUS = "active"

  delegate :to_json, to: :metadata_json # field in the database

  def create!(initial_metadata:, user:)
    self.metadata_model = initial_metadata
    if self.valid?
      if initial_metadata.project_id == ProjectMetadata::DOI_NOT_MINTED
        self.draft_doi(user: user)
        self.save!
        ProvenanceEvent.generate_submission_events(project: self, user: user)
      else
        self.save!
      end
      # return doi
      self.metadata_model.project_id
    else
      nil
    end
  end

  def approve!(mediaflux_id:, current_user:)
    self.mediaflux_id = mediaflux_id
    self.metadata_model.status = Project::APPROVED_STATUS
    self.save!

    # create two provenance events, one for approving the project and
      # another for changing the status of the project
    ProvenanceEvent.generate_approval_events(project: self, user: current_user)

  end

  def reload
    super
    @metadata_model = ProjectMetadata.new_from_hash(self.metadata)
    self
  end

  def activate!(collection_id:, current_user:)
    response = Mediaflux::AssetMetadataRequest.new(session_token: current_user.mediaflux_session, id: collection_id)
    mediaflux_metadata = response.metadata # get the metadata of the collection from mediaflux

    return unless mediaflux_metadata[:collection] == true # If the collection id exists

    # check if the project doi in rails matches the project doi in mediaflux
    return unless mediaflux_metadata[:project_id] == self.metadata_model.project_id

    # activate a project by setting the status to 'active'
    self.metadata_model.status = Project::ACTIVE_STATUS

    # also read in the actual project directory
    self.metadata_model.project_directory = mediaflux_metadata[:project_directory]
    self.save!

    ProvenanceEvent.generate_active_events(project: self, user: current_user)
  end

  def draft_doi(user:)
    puldatacite = PULDatacite.new
    self.metadata_model.project_id = puldatacite.draft_doi
  end

  # Ideally this method should return a ProjectMetadata object (like `metadata_model` does)
  # but we'll keep them both while we are refactoring the code so that we don't break
  # everything at once since `metadata` is used everywhere.
  def metadata
    @metadata_hash = (metadata_json || {}).with_indifferent_access
  end

  def metadata_model
    @metadata_model ||= ProjectMetadata.new_from_hash(self.metadata)
  end

  def metadata_model=(new_metadata_model)
    @metadata_model = new_metadata_model
  end

  def metadata=(metadata_model)
    # Convert our metadata to a hash so it can be saved on our JSONB field
    metadata_hash = JSON.parse(metadata_model.to_json)
    self.metadata_json = metadata_hash
  end

  def title
    self.metadata_model.title
  end

  def departments
    unsorted = metadata_model.departments || []
    unsorted.sort
  end

  def project_directory
    return nil if metadata_model.project_directory.nil?
    dirname, basename = project_directory_pathname.split
    if (dirname.relative?)
      "#{Mediaflux::Connection.root_namespace}/#{safe_name(metadata_model.project_directory)}"
    else
      project_directory_pathname.to_s
    end
  end

  def project_directory_parent_path
    return Mediaflux::Connection.root_namespace if metadata_model.project_directory.nil?
    dirname  = project_directory_pathname.dirname
    if (dirname.relative?)
      Mediaflux::Connection.root_namespace
    else
      dirname.to_s
    end
  end

  def project_directory_short
    return nil if metadata_model.project_directory.nil?
    project_directory_pathname.basename.to_s
  end

  def status
    metadata_model.status
  end

  def pending?
    status == PENDING_STATUS
  end

  def in_mediaflux?
    mediaflux_id.present?
  end

  def self.users_projects(user)
    # See https://scalegrid.io/blog/using-jsonb-in-postgresql-how-to-effectively-store-index-json-data-in-postgresql/
    # for information on the @> operator
    uid = user.uid
    query_ro = '{"data_user_read_only":["' + uid + '"]}'
    query_rw = '{"data_user_read_write":["' + uid + '"]}'
    query = "(metadata_json @> ? :: jsonb) OR (metadata_json @> ? :: jsonb)"
    args = [query_ro, query_rw]
    if user.eligible_sponsor?
      query += "OR (metadata_json->>'data_sponsor' = ?)"
      args << uid
    end
    if user.eligible_manager?
      query += "OR (metadata_json->>'data_manager' = ?)"
      args << uid
    end
    Project.where( query, *args)
  end

  def self.sponsored_projects(sponsor)
    Project.where("metadata_json->>'data_sponsor' = ?", sponsor)
  end

  def self.managed_projects(manager)
    Project.where("metadata_json->>'data_manager' = ?", manager)
  end

  def self.pending_projects
    Project.where("mediaflux_id IS NULL")
  end

  def self.approved_projects
    Project.where("mediaflux_id IS NOT NULL")
  end

  def self.data_user_projects(user)
    # See https://scalegrid.io/blog/using-jsonb-in-postgresql-how-to-effectively-store-index-json-data-in-postgresql/
    # for information on the @> operator
    query_ro = '{"data_user_read_only":["' + user + '"]}'
    query_rw = '{"data_user_read_write":["' + user + '"]}'
    Project.where("(metadata_json @> ? :: jsonb) OR (metadata_json @> ? :: jsonb)", query_ro, query_rw)
  end

  def save_in_mediaflux(user:)
    ProjectMediaflux.save(project: self, user: user)
  end

  def created_by_user
    User.find_by(uid: metadata_model.created_by)
  end

  def to_xml
    ProjectMediaflux.xml_payload(project: self)
  end

  def mediaflux_document
    ProjectMediaflux.document(project: self)
  end

  def mediaflux_metadata(session_id:)
    @mediaflux_metadata ||= begin
      accum_req = Mediaflux::AssetMetadataRequest.new(session_token: session_id, id: mediaflux_id)
      accum_req.metadata
    end
    @mediaflux_metadata
  end

  def asset_count(session_id:)
    values = mediaflux_metadata(session_id:)
    values.fetch(:total_file_count, 0)
  end

  def self.default_storage_usage
    "0 KB"
  end

  def storage_usage(session_id:)
    return unless in_mediaflux?

    values = mediaflux_metadata(session_id:)
    #value = values.fetch(:size, 0)
    quota_value = values.fetch(:quota_used, '')

    if quota_value.blank?
      return self.class.default_storage_usage
    else
      return quota_value
    end
  end

  def self.default_storage_capacity
    "0 GB"
  end

  def storage_capacity(session_id:)
    values = mediaflux_metadata(session_id:)
    quota_value = values.fetch(:quota_allocation, '') #if quota does not exist, set value to an empty string

    if quota_value.blank?
      return self.class.default_storage_capacity
    else
      return quota_value
    end
  end

  # Fetches the first n files
  def file_list(session_id:, size: 10)
    return { files: [] } if mediaflux_id.nil?

    query_req = Mediaflux::QueryRequest.new(session_token: session_id, collection: mediaflux_id, deep_search: true)
    iterator_id = query_req.result

    iterator_req = Mediaflux::IteratorRequest.new(session_token: session_id, iterator: iterator_id, size: size)
    results = iterator_req.result

    # Destroy _after_ fetching the first set of results from iterator_req.
    # This call is required since it possible that we have read less assets than
    # what the collection has but we are done with the iterator.
    Mediaflux::IteratorDestroyRequest.new(session_token: session_id, iterator: iterator_id).resolve

    results
  end

  # Fetches the entire file list to a file
  def file_list_to_file(session_id:, filename:)
    return { files: [] } if mediaflux_id.nil?

    query_req = Mediaflux::QueryRequest.new(session_token: session_id, collection: mediaflux_id, deep_search: true)
    iterator_id = query_req.result


    File.open(filename, "w") do |file|
      # file header
      file.write("ID, PATH, NAME, COLLECTION?, LAST_MODIFIED, SIZE\r\n")
      loop do
        iterator_req = Mediaflux::IteratorRequest.new(session_token: session_id, iterator: iterator_id, size: 1000)
        iterator_resp = iterator_req.result
        lines = files_from_iterator(iterator_resp)
        file.write(lines.join("\r\n") + "\r\n")
        break if iterator_resp[:complete]
      end
    end

    # Destroy _after_ fetching the results from iterator_req
    # This call is technically not necessary since Mediaflux automatically deletes the iterator
    # once we have ran through it and by now we have. But it does not hurt either.
    Mediaflux::IteratorDestroyRequest.new(session_token: session_id, iterator: iterator_id).resolve
  end

  # Ensure that the project directory is a valid path
  # @example
  #   Project.safe_name("My Project") # => "My-Project"
  def self.safe_name(name)
    # only alphanumeric characters
    name.strip.gsub(/[^A-Za-z\d]/, "-")
  end

  private

    def files_from_iterator(iterator_resp)
      lines = []
      iterator_resp[:files].each do |asset|
        lines << "#{asset.id}, #{asset.path_only}, #{asset.name}, #{asset.collection}, #{asset.last_modified}, #{asset.size}"
      end
      lines
    end

    def project_directory_pathname
      # allow the directory to be modified by changes in the metadata_json
      @project_directory_pathname = nil if @original_directory.present? && @original_directory != metadata_model.project_directory

      @project_directory_pathname ||= begin
        @original_directory = metadata_model.project_directory
        Pathname.new(@original_directory)
      end
    end

    # Ensure that the project directory is a valid path
    def safe_name(name)
      Project.safe_name(name)
    end
end

1	# frozen_string_literal: true
2	class Project < ApplicationRecord	1✔
3	validates_with ProjectValidator	1✔
4	has_many :provenance_events, dependent: :destroy	1✔
5	before_save do \|project\|	1✔
6	# Ensure that the metadata JSONB postgres field is persisted properly
7	project.metadata = project.metadata_model	405✔
8	end
9
10	# Valid project status described in ADR 7
11	# See `architecture-decisions/0007-valid-project-statuses.md`
12	PENDING_STATUS = "pending"	1✔
13	APPROVED_STATUS = "approved"	1✔
14	ACTIVE_STATUS = "active"	1✔
15
16	delegate :to_json, to: :metadata_json # field in the database	1✔
17
18	def create!(initial_metadata:, user:)	1✔
19	self.metadata_model = initial_metadata	19✔
20	if self.valid?	19✔
21	if initial_metadata.project_id == ProjectMetadata::DOI_NOT_MINTED	17✔
22	self.draft_doi(user: user)	13✔
23	self.save!	13✔
24	ProvenanceEvent.generate_submission_events(project: self, user: user)	13✔
25	else
26	self.save!	4✔
27	end
28	# return doi
29	self.metadata_model.project_id	17✔
30	else
31	nil
32	end
33	end
34
35	def approve!(mediaflux_id:, current_user:)	1✔
36	self.mediaflux_id = mediaflux_id	9✔
37	self.metadata_model.status = Project::APPROVED_STATUS	9✔
38	self.save!	9✔
39
40	# create two provenance events, one for approving the project and
41	# another for changing the status of the project
42	ProvenanceEvent.generate_approval_events(project: self, user: current_user)	9✔
43
44	end
45
46	def reload	1✔
47	super	28✔
48	@metadata_model = ProjectMetadata.new_from_hash(self.metadata)	28✔
49	self	28✔
50	end
51
52	def activate!(collection_id:, current_user:)	1✔
53	response = Mediaflux::AssetMetadataRequest.new(session_token: current_user.mediaflux_session, id: collection_id)	3✔
54	mediaflux_metadata = response.metadata # get the metadata of the collection from mediaflux	3✔
55
56	return unless mediaflux_metadata[:collection] == true # If the collection id exists	3✔
57
58	# check if the project doi in rails matches the project doi in mediaflux
59	return unless mediaflux_metadata[:project_id] == self.metadata_model.project_id	3✔
60
61	# activate a project by setting the status to 'active'
62	self.metadata_model.status = Project::ACTIVE_STATUS	2✔
63
64	# also read in the actual project directory
65	self.metadata_model.project_directory = mediaflux_metadata[:project_directory]	2✔
66	self.save!	2✔
67
68	ProvenanceEvent.generate_active_events(project: self, user: current_user)	2✔
69	end
70
71	def draft_doi(user:)	1✔
72	puldatacite = PULDatacite.new	13✔
73	self.metadata_model.project_id = puldatacite.draft_doi	13✔
74	end
75
76	# Ideally this method should return a ProjectMetadata object (like `metadata_model` does)
77	# but we'll keep them both while we are refactoring the code so that we don't break
78	# everything at once since `metadata` is used everywhere.
79	def metadata	1✔
80	@metadata_hash = (metadata_json \|\| {}).with_indifferent_access	512✔
81	end
82
83	def metadata_model	1✔
84	@metadata_model \|\|= ProjectMetadata.new_from_hash(self.metadata)	5,231✔
85	end
86
87	def metadata_model=(new_metadata_model)	1✔
88	@metadata_model = new_metadata_model	316✔
89	end
90
91	def metadata=(metadata_model)	1✔
92	# Convert our metadata to a hash so it can be saved on our JSONB field
93	metadata_hash = JSON.parse(metadata_model.to_json)	839✔
94	self.metadata_json = metadata_hash	839✔
95	end
96
97	def title	1✔
98	self.metadata_model.title	284✔
99	end
100
101	def departments	1✔
102	unsorted = metadata_model.departments \|\| []	175✔
103	unsorted.sort	175✔
104	end
105
106	def project_directory	1✔
107	return nil if metadata_model.project_directory.nil?	270✔
108	dirname, basename = project_directory_pathname.split	270✔
109	if (dirname.relative?)	270✔
110	"#{Mediaflux::Connection.root_namespace}/#{safe_name(metadata_model.project_directory)}"	266✔
111	else
112	project_directory_pathname.to_s	4✔
113	end
114	end
115
116	def project_directory_parent_path	1✔
117	return Mediaflux::Connection.root_namespace if metadata_model.project_directory.nil?	39✔
118	dirname = project_directory_pathname.dirname	26✔
119	if (dirname.relative?)	26✔
120	Mediaflux::Connection.root_namespace	24✔
121	else
122	dirname.to_s	2✔
123	end
124	end
125
126	def project_directory_short	1✔
127	return nil if metadata_model.project_directory.nil?	130✔
128	project_directory_pathname.basename.to_s	117✔
129	end
130
131	def status	1✔
132	metadata_model.status	256✔
133	end
134
135	def pending?	1✔
136	status == PENDING_STATUS	69✔
137	end
138
139	def in_mediaflux?	1✔
140	mediaflux_id.present?	183✔
141	end
142
143	def self.users_projects(user)	1✔
144	# See https://scalegrid.io/blog/using-jsonb-in-postgresql-how-to-effectively-store-index-json-data-in-postgresql/
145	# for information on the @> operator
146	uid = user.uid	59✔
147	query_ro = '{"data_user_read_only":["' + uid + '"]}'	59✔
148	query_rw = '{"data_user_read_write":["' + uid + '"]}'	59✔
149	query = "(metadata_json @> ? :: jsonb) OR (metadata_json @> ? :: jsonb)"	59✔
150	args = [query_ro, query_rw]	59✔
151	if user.eligible_sponsor?	59✔
152	query += "OR (metadata_json->>'data_sponsor' = ?)"	29✔
153	args << uid	29✔
154	end
155	if user.eligible_manager?	59✔
156	query += "OR (metadata_json->>'data_manager' = ?)"	13✔
157	args << uid	13✔
158	end
159	Project.where( query, *args)	59✔
160	end
161
162	def self.sponsored_projects(sponsor)	1✔
163	Project.where("metadata_json->>'data_sponsor' = ?", sponsor)	1✔
164	end
165
166	def self.managed_projects(manager)	1✔
167	Project.where("metadata_json->>'data_manager' = ?", manager)	1✔
168	end
169
170	def self.pending_projects	1✔
171	Project.where("mediaflux_id IS NULL")	56✔
172	end
173
174	def self.approved_projects	1✔
175	Project.where("mediaflux_id IS NOT NULL")	56✔
176	end
177
178	def self.data_user_projects(user)	1✔
179	# See https://scalegrid.io/blog/using-jsonb-in-postgresql-how-to-effectively-store-index-json-data-in-postgresql/
180	# for information on the @> operator
181	query_ro = '{"data_user_read_only":["' + user + '"]}'	1✔
182	query_rw = '{"data_user_read_write":["' + user + '"]}'	1✔
183	Project.where("(metadata_json @> ? :: jsonb) OR (metadata_json @> ? :: jsonb)", query_ro, query_rw)	1✔
184	end
185
186	def save_in_mediaflux(user:)	1✔
187	ProjectMediaflux.save(project: self, user: user)	16✔
188	end
189
190	def created_by_user	1✔
191	User.find_by(uid: metadata_model.created_by)	12✔
192	end
193
194	def to_xml	1✔
195	ProjectMediaflux.xml_payload(project: self)	5✔
196	end
197
198	def mediaflux_document	1✔
199	ProjectMediaflux.document(project: self)	×
200	end
201
202	def mediaflux_metadata(session_id:)	1✔
203	@mediaflux_metadata \|\|= begin	87✔
204	accum_req = Mediaflux::AssetMetadataRequest.new(session_token: session_id, id: mediaflux_id)	68✔
205	accum_req.metadata	68✔
206	end
207	@mediaflux_metadata	86✔
208	end
209
210	def asset_count(session_id:)	1✔
211	values = mediaflux_metadata(session_id:)	7✔
212	values.fetch(:total_file_count, 0)	7✔
213	end
214
215	def self.default_storage_usage	1✔
216	"0 KB"	4✔
217	end
218
219	def storage_usage(session_id:)	1✔
220	return unless in_mediaflux?	67✔
221
222	values = mediaflux_metadata(session_id:)	12✔
223	#value = values.fetch(:size, 0)
224	quota_value = values.fetch(:quota_used, '')	11✔
225
226	if quota_value.blank?	11✔
227	return self.class.default_storage_usage	4✔
228	else
229	return quota_value	7✔
230	end
231	end
232
233	def self.default_storage_capacity	1✔
234	"0 GB"	59✔
235	end
236
237	def storage_capacity(session_id:)	1✔
238	values = mediaflux_metadata(session_id:)	66✔
239	quota_value = values.fetch(:quota_allocation, '') #if quota does not exist, set value to an empty string	66✔
240
241	if quota_value.blank?	66✔
242	return self.class.default_storage_capacity	59✔
243	else
244	return quota_value	7✔
245	end
246	end
247
248	# Fetches the first n files
249	def file_list(session_id:, size: 10)	1✔
250	return { files: [] } if mediaflux_id.nil?	9✔
251
252	query_req = Mediaflux::QueryRequest.new(session_token: session_id, collection: mediaflux_id, deep_search: true)	9✔
253	iterator_id = query_req.result	9✔
254
255	iterator_req = Mediaflux::IteratorRequest.new(session_token: session_id, iterator: iterator_id, size: size)	9✔
256	results = iterator_req.result	9✔
257
258	# Destroy _after_ fetching the first set of results from iterator_req.
259	# This call is required since it possible that we have read less assets than
260	# what the collection has but we are done with the iterator.
261	Mediaflux::IteratorDestroyRequest.new(session_token: session_id, iterator: iterator_id).resolve	9✔
262
263	results	9✔
264	end
265
266	# Fetches the entire file list to a file
267	def file_list_to_file(session_id:, filename:)	1✔
268	return { files: [] } if mediaflux_id.nil?	8✔
269
270	query_req = Mediaflux::QueryRequest.new(session_token: session_id, collection: mediaflux_id, deep_search: true)	8✔
271	iterator_id = query_req.result	8✔
272
273
274	File.open(filename, "w") do \|file\|	8✔
275	# file header
276	file.write("ID, PATH, NAME, COLLECTION?, LAST_MODIFIED, SIZE\r\n")	8✔
277	loop do	8✔
278	iterator_req = Mediaflux::IteratorRequest.new(session_token: session_id, iterator: iterator_id, size: 1000)	8✔
279	iterator_resp = iterator_req.result	8✔
280	lines = files_from_iterator(iterator_resp)	8✔
281	file.write(lines.join("\r\n") + "\r\n")	8✔
282	break if iterator_resp[:complete]	8✔
283	end
284	end
285
286	# Destroy _after_ fetching the results from iterator_req
287	# This call is technically not necessary since Mediaflux automatically deletes the iterator
288	# once we have ran through it and by now we have. But it does not hurt either.
289	Mediaflux::IteratorDestroyRequest.new(session_token: session_id, iterator: iterator_id).resolve	8✔
290	end
291
292	# Ensure that the project directory is a valid path
293	# @example
294	# Project.safe_name("My Project") # => "My-Project"
295	def self.safe_name(name)	1✔
296	# only alphanumeric characters
297	name.strip.gsub(/[^A-Za-z\d]/, "-")	272✔
298	end
299
300	private	1✔
301
302	def files_from_iterator(iterator_resp)	1✔
303	lines = []	8✔
304	iterator_resp[:files].each do \|asset\|	8✔
UNCOV 305	lines << "#{asset.id}, #{asset.path_only}, #{asset.name}, #{asset.collection}, #{asset.last_modified}, #{asset.size}"	×
306	end
307	lines	8✔
308	end
309
310	def project_directory_pathname	1✔
311	# allow the directory to be modified by changes in the metadata_json
312	@project_directory_pathname = nil if @original_directory.present? && @original_directory != metadata_model.project_directory	417✔
313
314	@project_directory_pathname \|\|= begin	417✔
315	@original_directory = metadata_model.project_directory	143✔
316	Pathname.new(@original_directory)	143✔
317	end
318	end
319
320	# Ensure that the project directory is a valid path
321	def safe_name(name)	1✔
322	Project.safe_name(name)	266✔
323	end
324	end

pulibrary / tigerdata-app / a7a7c677-70ce-4fb7-93a9-85b7a17ef43a

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