2019cefc-a8e6-4859-80c7-47af78cd7e4c

Committed 07 Nov 2025 06:12PM UTC coverage: 88.239% (-3.1%) from 91.357%

Build # 2019cefc-a8e6-4859-80c7-47af78cd7e4c

Build Type

Pull #2163

circleci

Committed by

web-flow

Commit Message

Merge branch 'main' into 2157-project-list-error

Pull Request Pull Request #2163: Logs Mediaflux errors when fetching the project list

Run Details

8 of 8 new or added lines in 1 file covered. (100.0%)

498 existing lines in 29 files now uncovered.

2761 of 3129 relevant lines covered (88.24%)

488.86 hits per line

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

92.31

/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`
  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 activate(current_user:)
    raise StandardError.new("Only approved projects can be activated") if self.status != Project::APPROVED_STATUS
    metadata_request = Mediaflux::AssetMetadataRequest.new(session_token: current_user.mediaflux_session, id: self.mediaflux_id)
    metadata_request.resolve
    raise metadata_request.response_error if metadata_request.error?
    if self.title == metadata_request.metadata[:title]
      self.metadata_model.status = Project::ACTIVE_STATUS
      self.save!
    else
      raise StandardError.new("Title mismatch: #{self.title} != #{metadata_request.metadata[:title]}")
    end
  end

  def draft_doi(user: nil)
    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
    metadata_model.project_directory || ""
  end

  def project_directory_short
    project_directory
  end

  def status
    metadata_model.status
  end

  def in_mediaflux?
    mediaflux_id.present?
  end

  # This method narrows the list down returned by `all_projects` to only those projects where the user has
  # been given a role (e.g. sponsor, manager, or data user.) For most users `all_projects` and `user_projects`
  # are identical, but for administrators the lists can be very different since they are not part of most
  # projects even though they have access to them in Mediaflux.
  def self.users_projects(user)
    all_projects(user).select do |project|
      project[:data_manager] == user.uid || project[:data_sponsor] == user.uid || project[:data_users].include?(user.uid)
    end
  end

  # Returns the projects that the current user has access in Mediaflux given their credentials
  def self.all_projects(user, aql_query = "xpath(tigerdata:project/ProjectID) has value")
    request = Mediaflux::ProjectListRequest.new(session_token: user.mediaflux_session, aql_query:)
    request.resolve
    if request.error?
      Rails.logger.error("Error fetching project list for user #{user&.uid}: #{request.response_error[:message]}")
      Honeybadger.notify("Error fetching project list for user #{user&.uid}: #{request.response_error[:message]}")
      []
    else
      request.results
    end
  end

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

  # @return [String] XML representation of the <meta> element
  def mediaflux_meta_xml(user:)
    doc = ProjectMediaflux.document(project: self, user: user)
    doc.xpath("/response/reply/result/asset/meta").to_s
  end

  def mediaflux_metadata(session_id:)
    @mediaflux_metadata ||= begin
      metadata_request = Mediaflux::AssetMetadataRequest.new(session_token: session_id, id: mediaflux_id)
      metadata_request.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_unit
    "KB"
  end

  def self.default_storage_usage
    "0 #{default_storage_unit}"
  end

  def storage_usage(session_id:)
    values = mediaflux_metadata(session_id:)
    values.fetch(:quota_used, self.class.default_storage_usage) # if the storage is empty use the default
  end

  def storage_usage_raw(session_id:)
    values = mediaflux_metadata(session_id:)
    values.fetch(:quota_used_raw, 0) # if the storage raw is empty use zero
  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

  def storage_capacity_raw(session_id:)
    values = mediaflux_metadata(session_id:)
    quota_value = values.fetch(:quota_allocation_raw, 0) #if quota does not exist, set value to 0
    quota_value
  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, aql_query: "type!='application/arc-asset-collection'")
    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,  aql_query: "type!='application/arc-asset-collection'")
    iterator_id = query_req.result

    start_time = Time.zone.now
    prefix = "file_list_to_file #{session_id[0..7]} #{self.metadata_model.project_id}"
    log_elapsed(start_time, prefix, "STARTED")

    File.open(filename, "w") do |file|
      page_number = 0
      # file header
      file.write("ID, PATH, NAME, COLLECTION?, LAST_MODIFIED, SIZE\r\n")
      loop do
        iterator_start_time = Time.zone.now
        page_number += 1
        iterator_req = Mediaflux::IteratorRequest.new(session_token: session_id, iterator: iterator_id, size: 1000)
        iterator_resp = iterator_req.result
        log_elapsed(iterator_start_time, prefix, "FETCHED page #{page_number} from iterator")
        lines = files_from_iterator(iterator_resp)
        file.write(lines.join("\r\n") + "\r\n")
        break if iterator_resp[:complete] || iterator_req.error?
      end
      log_elapsed(start_time, prefix, "ENDED")
    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


  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_directory(directory)
      Project.safe_directory(directory)
    end

    def log_elapsed(start_time, prefix, message)
      elapsed_time = Time.zone.now - start_time
      timing_info = "#{format('%.2f', elapsed_time)} s"
      Rails.logger.info "#{prefix}: #{message}, #{timing_info}"
    end
end

1	# frozen_string_literal: true
2	class Project < ApplicationRecord	4✔
3
4	validates_with ProjectValidator	4✔
5	has_many :provenance_events, dependent: :destroy	4✔
6	before_save do \|project\|	4✔
7	# Ensure that the metadata JSONB postgres field is persisted properly
8	project.metadata = project.metadata_model	1,147✔
9	end
10
11	# Valid project status described in ADR 7
12	# See `architecture-decisions/0007-valid-project-statuses.md`
13	APPROVED_STATUS = "approved"	4✔
14	ACTIVE_STATUS = "active"	4✔
15
16	delegate :to_json, to: :metadata_json # field in the database	4✔
17
18	def create!(initial_metadata:, user:)	4✔
19	self.metadata_model = initial_metadata	5✔
20	if self.valid?	5✔
21	if initial_metadata.project_id == ProjectMetadata::DOI_NOT_MINTED	3✔
22	self.draft_doi(user: user)	2✔
23	self.save!	2✔
24	ProvenanceEvent.generate_submission_events(project: self, user: user)	2✔
25	else
26	self.save!	1✔
27	end
28	# return doi
29	self.metadata_model.project_id	3✔
30	else
31	nil
32	end
33	end
34
35	def activate(current_user:)	4✔
36	raise StandardError.new("Only approved projects can be activated") if self.status != Project::APPROVED_STATUS	251✔
37	metadata_request = Mediaflux::AssetMetadataRequest.new(session_token: current_user.mediaflux_session, id: self.mediaflux_id)	251✔
38	metadata_request.resolve	251✔
39	raise metadata_request.response_error if metadata_request.error?	251✔
40	if self.title == metadata_request.metadata[:title]	251✔
41	self.metadata_model.status = Project::ACTIVE_STATUS	251✔
42	self.save!	251✔
43	else
44	raise StandardError.new("Title mismatch: #{self.title} != #{metadata_request.metadata[:title]}")	×
45	end
46	end
47
48	def draft_doi(user: nil)	4✔
49	puldatacite = PULDatacite.new	259✔
50	self.metadata_model.project_id = puldatacite.draft_doi	259✔
51	end
52
53	# Ideally this method should return a ProjectMetadata object (like `metadata_model` does)
54	# but we'll keep them both while we are refactoring the code so that we don't break
55	# everything at once since `metadata` is used everywhere.
56	def metadata	4✔
57	@metadata_hash = (metadata_json \|\| {}).with_indifferent_access	471✔
58	end
59
60	def metadata_model	4✔
61	@metadata_model \|\|= ProjectMetadata.new_from_hash(self.metadata)	13,832✔
62	end
63
64	def metadata_model=(new_metadata_model)	4✔
65	@metadata_model = new_metadata_model	101✔
66	end
67
68	def metadata=(metadata_model)	4✔
69	# Convert our metadata to a hash so it can be saved on our JSONB field
70	metadata_hash = JSON.parse(metadata_model.to_json)	2,356✔
71	self.metadata_json = metadata_hash	2,356✔
72	end
73
74	def title	4✔
75	self.metadata_model.title	367✔
76	end
77
78	def departments	4✔
79	unsorted = metadata_model.departments \|\| []	×
80	unsorted.sort	×
81	end
82
83	def project_directory	4✔
84	metadata_model.project_directory \|\| ""	161✔
85	end
86
87	def project_directory_short	4✔
UNCOV 88	project_directory	6✔
89	end
90
91	def status	4✔
92	metadata_model.status	607✔
93	end
94
95	def in_mediaflux?	4✔
UNCOV 96	mediaflux_id.present?	22✔
97	end
98
99	# This method narrows the list down returned by `all_projects` to only those projects where the user has
100	# been given a role (e.g. sponsor, manager, or data user.) For most users `all_projects` and `user_projects`
101	# are identical, but for administrators the lists can be very different since they are not part of most
102	# projects even though they have access to them in Mediaflux.
103	def self.users_projects(user)	4✔
104	all_projects(user).select do \|project\|	69✔
105	project[:data_manager] == user.uid \|\| project[:data_sponsor] == user.uid \|\| project[:data_users].include?(user.uid)	3,692✔
106	end
107	end
108
109	# Returns the projects that the current user has access in Mediaflux given their credentials
110	def self.all_projects(user, aql_query = "xpath(tigerdata:project/ProjectID) has value")	4✔
111	request = Mediaflux::ProjectListRequest.new(session_token: user.mediaflux_session, aql_query:)	74✔
112	request.resolve	74✔
113	if request.error?	74✔
114	Rails.logger.error("Error fetching project list for user #{user&.uid}: #{request.response_error[:message]}")	1✔
115	Honeybadger.notify("Error fetching project list for user #{user&.uid}: #{request.response_error[:message]}")	1✔
116	[]	1✔
117	else
118	request.results	73✔
119	end
120	end
121
122	def created_by_user	4✔
123	User.find_by(uid: metadata_model.created_by)	×
124	end
125
126	# @return [String] XML representation of the <meta> element
127	def mediaflux_meta_xml(user:)	4✔
128	doc = ProjectMediaflux.document(project: self, user: user)	3✔
129	doc.xpath("/response/reply/result/asset/meta").to_s	3✔
130	end
131
132	def mediaflux_metadata(session_id:)	4✔
133	@mediaflux_metadata \|\|= begin	853✔
134	metadata_request = Mediaflux::AssetMetadataRequest.new(session_token: session_id, id: mediaflux_id)	150✔
135	metadata_request.metadata	150✔
136	end
137	@mediaflux_metadata	849✔
138	end
139
140	def asset_count(session_id:)	4✔
141	values = mediaflux_metadata(session_id:)	29✔
142	values.fetch(:total_file_count, 0)	29✔
143	end
144
145	def self.default_storage_unit	4✔
146	"KB"	217✔
147	end
148
149	def self.default_storage_usage	4✔
150	"0 #{default_storage_unit}"	216✔
151	end
152
153	def storage_usage(session_id:)	4✔
154	values = mediaflux_metadata(session_id:)	215✔
155	values.fetch(:quota_used, self.class.default_storage_usage) # if the storage is empty use the default	215✔
156	end
157
158	def storage_usage_raw(session_id:)	4✔
UNCOV 159	values = mediaflux_metadata(session_id:)	141✔
UNCOV 160	values.fetch(:quota_used_raw, 0) # if the storage raw is empty use zero	141✔
161	end
162
163	def self.default_storage_capacity	4✔
164	"0 GB"	×
165	end
166
167	def storage_capacity(session_id:)	4✔
168	values = mediaflux_metadata(session_id:)	215✔
169	quota_value = values.fetch(:quota_allocation, '') #if quota does not exist, set value to an empty string	215✔
170	if quota_value.blank?	215✔
171	return self.class.default_storage_capacity	×
172	else
173	return quota_value	215✔
174	end
175	end
176
177	def storage_capacity_raw(session_id:)	4✔
UNCOV 178	values = mediaflux_metadata(session_id:)	173✔
UNCOV 179	quota_value = values.fetch(:quota_allocation_raw, 0) #if quota does not exist, set value to 0	173✔
UNCOV 180	quota_value	173✔
181	end
182
183	# Fetches the first n files
184	def file_list(session_id:, size: 10)	4✔
185	return { files: [] } if mediaflux_id.nil?	32✔
186
187	query_req = Mediaflux::QueryRequest.new(session_token: session_id, collection: mediaflux_id, deep_search: true, aql_query: "type!='application/arc-asset-collection'")	32✔
188	iterator_id = query_req.result	32✔
189
190	iterator_req = Mediaflux::IteratorRequest.new(session_token: session_id, iterator: iterator_id, size: size)	32✔
191	results = iterator_req.result	32✔
192
193	# Destroy _after_ fetching the first set of results from iterator_req.
194	# This call is required since it possible that we have read less assets than
195	# what the collection has but we are done with the iterator.
196	Mediaflux::IteratorDestroyRequest.new(session_token: session_id, iterator: iterator_id).resolve	32✔
197
198	results	32✔
199	end
200
201	# Fetches the entire file list to a file
202	def file_list_to_file(session_id:, filename:)	4✔
UNCOV 203	return { files: [] } if mediaflux_id.nil?	2✔
204
UNCOV 205	query_req = Mediaflux::QueryRequest.new(session_token: session_id, collection: mediaflux_id, deep_search: true, aql_query: "type!='application/arc-asset-collection'")	2✔
UNCOV 206	iterator_id = query_req.result	2✔
207
UNCOV 208	start_time = Time.zone.now	2✔
UNCOV 209	prefix = "file_list_to_file #{session_id[0..7]} #{self.metadata_model.project_id}"	2✔
UNCOV 210	log_elapsed(start_time, prefix, "STARTED")	2✔
211
UNCOV 212	File.open(filename, "w") do \|file\|	2✔
UNCOV 213	page_number = 0	2✔
214	# file header
UNCOV 215	file.write("ID, PATH, NAME, COLLECTION?, LAST_MODIFIED, SIZE\r\n")	2✔
UNCOV 216	loop do	2✔
UNCOV 217	iterator_start_time = Time.zone.now	2✔
UNCOV 218	page_number += 1	2✔
UNCOV 219	iterator_req = Mediaflux::IteratorRequest.new(session_token: session_id, iterator: iterator_id, size: 1000)	2✔
UNCOV 220	iterator_resp = iterator_req.result	2✔
UNCOV 221	log_elapsed(iterator_start_time, prefix, "FETCHED page #{page_number} from iterator")	2✔
UNCOV 222	lines = files_from_iterator(iterator_resp)	2✔
UNCOV 223	file.write(lines.join("\r\n") + "\r\n")	2✔
UNCOV 224	break if iterator_resp[:complete] \|\| iterator_req.error?	2✔
225	end
UNCOV 226	log_elapsed(start_time, prefix, "ENDED")	2✔
227	end
228
229	# Destroy _after_ fetching the results from iterator_req
230	# This call is technically not necessary since Mediaflux automatically deletes the iterator
231	# once we have ran through it and by now we have. But it does not hurt either.
UNCOV 232	Mediaflux::IteratorDestroyRequest.new(session_token: session_id, iterator: iterator_id).resolve	2✔
233	end
234
235
236	private	4✔
237
238	def files_from_iterator(iterator_resp)	4✔
UNCOV 239	lines = []	2✔
UNCOV 240	iterator_resp[:files].each do \|asset\|	2✔
241	lines << "#{asset.id}, #{asset.path_only}, #{asset.name}, #{asset.collection}, #{asset.last_modified}, #{asset.size}"	16✔
242	end
UNCOV 243	lines	2✔
244	end
245
246	def project_directory_pathname	4✔
247	# allow the directory to be modified by changes in the metadata_json
248	@project_directory_pathname = nil if @original_directory.present? && @original_directory != metadata_model.project_directory	×
249
250	@project_directory_pathname \|\|= begin	×
251	@original_directory = metadata_model.project_directory	×
252	Pathname.new(@original_directory)	×
253	end
254	end
255
256	# Ensure that the project directory is a valid path
257	def safe_directory(directory)	4✔
258	Project.safe_directory(directory)	×
259	end
260
261	def log_elapsed(start_time, prefix, message)	4✔
UNCOV 262	elapsed_time = Time.zone.now - start_time	6✔
UNCOV 263	timing_info = "#{format('%.2f', elapsed_time)} s"	6✔
UNCOV 264	Rails.logger.info "#{prefix}: #{message}, #{timing_info}"	6✔
265	end
266	end

pulibrary / tigerdata-app / 2019cefc-a8e6-4859-80c7-47af78cd7e4c

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