Class: Work

Inherits:
ApplicationRecord show all
Includes:
AASM
Defined in:
app/models/work.rb

Overview

rubocop:disable Metrics/ClassLength

Defined Under Namespace

Classes: InvalidGroupError

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#user_entered_doi ⇒ Object

Returns the value of attribute user_entered_doi.



18
19
20
 
# File 'app/models/work.rb', line 18

def user_entered_doi
  @user_entered_doi
end

Class Method Details

.find_by_ark(ark) ⇒ Object 



107
108
109
110
111
 
# File 'app/models/work.rb', line 107

def find_by_ark(ark)
  prefix = "ark:/"
  ark = "#{prefix}#{ark}" unless ark.blank? || ark.start_with?(prefix)
  Work.find_by!("metadata @> ?", JSON.dump(ark:))
end

.find_by_doi(doi) ⇒ Object 



101
102
103
104
105
 
# File 'app/models/work.rb', line 101

def find_by_doi(doi)
  prefix = "10.34770/"
  doi = "#{prefix}#{doi}" unless doi.blank? || doi.start_with?(prefix)
  Work.find_by!("metadata @> ?", JSON.dump(doi:))
end

.list_embargoed ⇒ Object 



115
116
117
 
# File 'app/models/work.rb', line 115

def list_embargoed
  Work.where("embargo_date >= current_date").where(state: "approved")
end

.list_released_embargo ⇒ Object 



119
120
121
 
# File 'app/models/work.rb', line 119

def list_released_embargo
  Work.where("embargo_date = current_date-1").where(state: "approved")
end

.presenter_class ⇒ Object 



510
511
512
 
# File 'app/models/work.rb', line 510

def self.presenter_class
  WorkPresenter
end

Instance Method Details

#activities ⇒ Object 



288
289
290
 
# File 'app/models/work.rb', line 288

def activities
  WorkActivity.activities_for_work(id, WorkActivity::MESSAGE_ACTIVITY_TYPES + WorkActivity::CHANGE_LOG_ACTIVITY_TYPES)
end

#add_message(message, current_user_id) ⇒ Object 



270
271
272
 
# File 'app/models/work.rb', line 270

def add_message(message, current_user_id)
  WorkActivity.add_work_activity(id, message, current_user_id, activity_type: WorkActivity::MESSAGE)
end

#add_provenance_note(date, note, current_user_id, change_label = "") ⇒ Object 



274
275
276
 
# File 'app/models/work.rb', line 274

def add_provenance_note(date, note, current_user_id, change_label = "")
  WorkActivity.add_work_activity(id, { note:, change_label: }.to_json, current_user_id, activity_type: WorkActivity::PROVENANCE_NOTES, created_at: date)
end

#administered_by?(user) ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
 
# File 'app/models/work.rb', line 96

def administered_by?(user)
  user.has_role?(:group_admin, group)
end

#artifact_uploads ⇒ Array<S3File>

Retrieve the S3 file uploads which are research artifacts proper (not README or other files providing metadata/documentation)

Returns:



344
345
346
 
# File 'app/models/work.rb', line 344

def artifact_uploads
  uploads.reject { |s3_file| s3_file.filename.include?("README") }
end

#as_json(*args) ⇒ String

Generates the JSON serialized expression of the Work

Parameters:

  • args (Array<Hash>)

Options Hash (*args):

  • :force_post_curation (Boolean) —

    Force the request of AWS S3 Resources, clearing the in-memory cache

Returns:

  • (String) 


451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
 
# File 'app/models/work.rb', line 451

def as_json(*args)
  files = files_as_json(*args)

  # to_json returns a string of serialized JSON.
  # as_json returns the corresponding hash.
  {
    "resource" => resource.as_json,
    "files" => files,
    "group" => group.as_json.except("id"),
    "embargo_date" => embargo_date_as_json,
    "created_at" => format_date_for_solr(created_at),
    "updated_at" => format_date_for_solr(updated_at),
    "date_approved" => date_approved
  }
end

#change_curator(curator_user_id, current_user) ⇒ Object 



229
230
231
232
233
234
235
 
# File 'app/models/work.rb', line 229

def change_curator(curator_user_id, current_user)
  if curator_user_id == "no-one"
    clear_curator(current_user)
  else
    update_curator(curator_user_id, current_user)
  end
end

#changes ⇒ Object 



518
519
520
 
# File 'app/models/work.rb', line 518

def changes
  @changes ||= []
end

#clear_curator(current_user) ⇒ Object 



237
238
239
240
241
242
243
244
 
# File 'app/models/work.rb', line 237

def clear_curator(current_user)
  # Update the curator on the Work
  self.curator_user_id = nil
  save!

  # ...and log the activity
  WorkActivity.add_work_activity(id, "Unassigned existing curator", current_user.id, activity_type: WorkActivity::SYSTEM)
end

#created_by_user ⇒ Object 



195
196
197
198
199
 
# File 'app/models/work.rb', line 195

def created_by_user
  User.find(created_by_user_id)
rescue ActiveRecord::RecordNotFound
  nil
end

#current_transition ⇒ Object 



324
325
326
 
# File 'app/models/work.rb', line 324

def current_transition
  aasm.current_event.to_s.humanize.delete("!")
end

#date_approved ⇒ Object 



575
576
577
578
579
 
# File 'app/models/work.rb', line 575

def date_approved
  @approved_activity ||= WorkActivity.where("work_id = ? and message='marked as Approved'", id).first
  return nil if @approved_activity.nil?
  @approved_activity.created_at.to_date.to_s
end

#doi_url ⇒ String

Return the DOI formatted as a URL, so it can be used as a link on display pages

Returns:

  • (String) —

    A url formatted version of the DOI



190
191
192
193
 
# File 'app/models/work.rb', line 190

def doi_url
  return "https://doi.org/#{doi}" unless doi.starts_with?("https://doi.org")
  doi
end

#draft_doi ⇒ Object 



182
183
184
185
186
 
# File 'app/models/work.rb', line 182

def draft_doi
  return if resource.doi.present?
  resource.doi = datacite_service.draft_doi
  save!
end

#editable_by?(user) ⇒ Boolean

Is this work editable by a given user? A work is editable when:

  • it is being edited by the person who made it

  • it is being edited by a group admin of the group where is resides

  • it is being edited by a super admin

Parameters:

Returns:

  • (Boolean) 


80
81
82
 
# File 'app/models/work.rb', line 80

def editable_by?(user)
  submitted_by?(user) || administered_by?(user)
end

#editable_in_current_state?(user) ⇒ Boolean

Returns:

  • (Boolean) 


84
85
86
87
88
89
90
 
# File 'app/models/work.rb', line 84

def editable_in_current_state?(user)
  # anyone with edit privleges can edit a work while it is in draft
  return editable_by?(user) if draft?

  # Only admisitrators can edit a work in other states
  administered_by?(user)
end

#embargoed? ⇒ Boolean

Determine whether or not the Work is under active embargo

Embargoes are not fully released until the day after the embargo date

Returns:

  • (Boolean) 


540
541
542
543
544
545
 
# File 'app/models/work.rb', line 540

def embargoed?
  return false if embargo_date.blank?

  current_date = Time.zone.now.to_date
  current_date <= embargo_date
end

#file_list ⇒ Object

Returns the list of files for the work with some basic information about each of them. This method is much faster than uploads because it does not return the actual S3File objects to the client, instead it returns just a few selected data elements. rubocop:disable Metrics/MethodLength



352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
 
# File 'app/models/work.rb', line 352

def file_list
  start = Time.zone.now
  s3_files = approved? ? post_curation_uploads : pre_curation_uploads
  files_info = s3_files.map do |s3_file|
    {
      "safe_id": s3_file.safe_id,
      "filename": s3_file.filename,
      "filename_display": s3_file.filename_display,
      "last_modified": s3_file.last_modified,
      "last_modified_display": s3_file.last_modified_display,
      "size": s3_file.size,
      "display_size": s3_file.display_size,
      "url": s3_file.url,
      "is_folder": s3_file.is_folder
    }
  end
  log_performance(start, "file_list called for #{id}")
  files_info
end

#files_location_cluster? ⇒ Boolean

Returns:

  • (Boolean) 


221
222
223
 
# File 'app/models/work.rb', line 221

def files_location_cluster?
  files_location == "file_cluster"
end

#files_location_other? ⇒ Boolean

Returns:

  • (Boolean) 


225
226
227
 
# File 'app/models/work.rb', line 225

def files_location_other?
  files_location == "file_other"
end

#files_location_upload? ⇒ Boolean

Returns:

  • (Boolean) 


217
218
219
 
# File 'app/models/work.rb', line 217

def files_location_upload?
  files_location.blank? || files_location == "file_upload"
end

#files_mode ⇒ Object

Returns the bucket name where the files are stored for this work.



563
564
565
566
567
568
569
570
571
572
573
 
# File 'app/models/work.rb', line 563

def files_mode
  if approved?
    if embargoed?
      PULS3Client::EMBARGO
    else
      PULS3Client::POSTCURATION
    end
  else
    PULS3Client::PRECURATION
  end
end

#files_mode_human ⇒ Object

Returns a human friendly name for the bucket where the files for the work are located. Notice that we don’t use the values from PULS3Client because those are not human friendly (e.g. the lack dashes between words)



550
551
552
553
554
555
556
557
558
559
560
 
# File 'app/models/work.rb', line 550

def files_mode_human
  if approved?
    if embargoed?
      "embargo"
    else
      "post-curation"
    end
  else
    "pre-curation"
  end
end

#find_bucket_s3_dir(bucket_name:) ⇒ Aws::S3::Types::HeadObjectOutput

Transmit a HEAD request for the S3 Bucket directory for this Work

Parameters:

  • bucket_name —

    location to be checked to be found

Returns:

  • (Aws::S3::Types::HeadObjectOutput) 


434
435
436
437
438
439
440
441
442
443
444
 
# File 'app/models/work.rb', line 434

def find_bucket_s3_dir(bucket_name:)
  # TODO: Directories really do not exists in S3
  #      if we really need this check then we need to do something else to check the bucket
  s3_client.head_object({
                          bucket: bucket_name,
                          key: s3_object_key
                        })
  true
rescue Aws::S3::Errors::NotFound
  nil
end

#form_attributes ⇒ Object 



176
177
178
179
180
 
# File 'app/models/work.rb', line 176

def form_attributes
  {
    uploads: uploads_attributes
  }
end

#format_date_for_solr(date) ⇒ String

Format the date for Apache Solr

Parameters:

  • date (ActiveSupport::TimeWithZone)

Returns:

  • (String) 


470
471
472
 
# File 'app/models/work.rb', line 470

def format_date_for_solr(date)
  date.strftime("%Y-%m-%dT%H:%M:%SZ")
end

#has_rights?(rights_id) ⇒ Boolean

rubocop:disable Naming/PredicateName

Returns:

  • (Boolean) 


527
528
529
 
# File 'app/models/work.rb', line 527

def has_rights?(rights_id)
  resource.rights_many.index { |rights| rights.identifier == rights_id } != nil
end

#log_changes(resource_compare, current_user_id) ⇒ Object 



278
279
280
281
 
# File 'app/models/work.rb', line 278

def log_changes(resource_compare, current_user_id)
  return if resource_compare.identical?
  WorkActivity.add_work_activity(id, resource_compare.differences.to_json, current_user_id, activity_type: WorkActivity::CHANGES)
end

#log_file_changes(current_user_id) ⇒ Object 



283
284
285
286
 
# File 'app/models/work.rb', line 283

def log_file_changes(current_user_id)
  return if changes.count == 0
  WorkActivity.add_work_activity(id, changes.to_json, current_user_id, activity_type: WorkActivity::FILE_CHANGES)
end

#mark_new_notifications_as_read(user_id) ⇒ Object

Marks as read the notifications for the given user_id in this work. In practice, the user_id is the id of the current user and therefore this method marks the current’s user notifications as read.



302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
 
# File 'app/models/work.rb', line 302

def mark_new_notifications_as_read(user_id)
  # Notice that we fetch and update the information in batches
  # so that we don't issue individual SQL SELECT + SQL UPDATE
  # for each notification.
  #
  # Rails batching information:
  #   https://guides.rubyonrails.org/active_record_querying.html
  #   https://api.rubyonrails.org/classes/ActiveRecord/Batches.html

  # Disable this validation since we want to force a SQL UPDATE.
  # rubocop:disable Rails/SkipsModelValidations
  now_utc = Time.now.utc

  WorkActivityNotification.joins(:work_activity)
                          .where(user_id:)
                          .where(work_activity: { work_id: id })
                          .in_batches(of: 1000)
                          .update_all(read_at: now_utc)

  # rubocop:enable Rails/SkipsModelValidations
end

#new_notification_count_for_user(user_id) ⇒ Object 



292
293
294
295
296
297
 
# File 'app/models/work.rb', line 292

def new_notification_count_for_user(user_id)
  WorkActivityNotification.joins(:work_activity)
                          .where(user_id:, read_at: nil)
                          .where(work_activity: { work_id: id })
                          .count
end

#past_snapshots ⇒ Object 



483
484
485
 
# File 'app/models/work.rb', line 483

def past_snapshots
  UploadSnapshot.where(work: self)
end

#pdc_discovery_url ⇒ Object

This is the solr id / work show page in PDC Discovery



533
534
535
 
# File 'app/models/work.rb', line 533

def pdc_discovery_url
  "https://datacommons.princeton.edu/discovery/catalog/doi-#{doi.tr('/', '-').tr('.', '-')}"
end

#post_curation_s3_resources ⇒ Object

Accesses post-curation S3 Bucket Objects



394
395
396
397
398
399
400
 
# File 'app/models/work.rb', line 394

def post_curation_s3_resources
  if approved?
    s3_resources
  else
    []
  end
end

#post_curation_uploads(force_post_curation: false) ⇒ Object

Returns the files in post-curation for the work



403
404
405
406
407
408
409
410
411
412
 
# File 'app/models/work.rb', line 403

def post_curation_uploads(force_post_curation: false)
  if force_post_curation
    # Always use the post-curation data regardless of the work's status
    post_curation_s3_query_service = S3QueryService.new(self, PULS3Client::POSTCURATION)
    post_curation_s3_query_service.data_profile.fetch(:objects, [])
  else
    # Return the list based of files honoring the work status
    post_curation_s3_resources
  end
end

#pre_curation_uploads ⇒ Object

Fetches the data from S3 directly bypassing ActiveStorage



389
390
391
 
# File 'app/models/work.rb', line 389

def pre_curation_uploads
  s3_query_service.client_s3_files.sort_by(&:filename)
end

#presenter ⇒ Object 



514
515
516
 
# File 'app/models/work.rb', line 514

def presenter
  self.class.presenter_class.new(work: self)
end

#readme_uploads ⇒ Array<S3File>

Retrieve the S3 file uploads named “README”

Returns:



338
339
340
 
# File 'app/models/work.rb', line 338

def readme_uploads
  uploads.select { |s3_file| s3_file.filename.include?("README") }
end

#reload(options = nil) ⇒ Object

Overload ActiveRecord.reload method apidock.com/rails/ActiveRecord/Base/reload

NOTE: Usually after_save is a better place to put this kind of code:

after_save do |work|
  work.resource = nil
end

but that does not work in this case because the block points to a different memory object for work than the we want we want to reload.



152
153
154
155
156
157
 
# File 'app/models/work.rb', line 152

def reload(options = nil)
  super
  # Force `resource` to be reloaded
  @resource = nil
  self
end

#reload_snapshots(user_id: nil) ⇒ UploadSnapshot

Build or find persisted UploadSnapshot models for this Work

Parameters:

  • user_id (integer) (defaults to: nil) —

    optional user to assign the snapshot to

Returns:



490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
 
# File 'app/models/work.rb', line 490

def reload_snapshots(user_id: nil)
  work_changes = []
  s3_files = pre_curation_uploads
  s3_filenames = s3_files.map(&:filename)

  upload_snapshot = latest_snapshot

  upload_snapshot.snapshot_deletions(work_changes, s3_filenames)

  upload_snapshot.snapshot_modifications(work_changes, s3_files)

  # Create WorkActivity models with the set of changes
  unless work_changes.empty?
    new_snapshot = UploadSnapshot.new(work: self, url: s3_query_service.prefix)
    new_snapshot.store_files(s3_files)
    new_snapshot.save!
    WorkActivity.add_work_activity(id, work_changes.to_json, user_id, activity_type: WorkActivity::FILE_CHANGES)
  end
end

#resource ⇒ Object 



207
208
209
 
# File 'app/models/work.rb', line 207

def resource
  @resource ||= PDCMetadata::Resource.new_from_jsonb(metadata)
end

#resource=(resource) ⇒ Object 



201
202
203
204
205
 
# File 'app/models/work.rb', line 201

def resource=(resource)
  @resource = resource
  # Ensure that the metadata JSONB postgres field is persisted properly
  self.metadata = JSON.parse(resource.to_json)
end

#s3_client ⇒ Object 



418
419
420
 
# File 'app/models/work.rb', line 418

def s3_client
  s3_query_service.client
end

#s3_files ⇒ Object 



414
415
416
 
# File 'app/models/work.rb', line 414

def s3_files
  pre_curation_uploads
end

#s3_object_key ⇒ String

Generates the S3 Object key

Returns:

  • (String) 


427
428
429
 
# File 'app/models/work.rb', line 427

def s3_object_key
  "#{doi}/#{id}"
end

#s3_query_service ⇒ S3QueryService

S3QueryService object associated with this Work

Returns:



479
480
481
 
# File 'app/models/work.rb', line 479

def s3_query_service
  @s3_query_service ||= S3QueryService.new(self, files_mode)
end

#state=(new_state) ⇒ Object

Raises:

  • (StandardError) 


65
66
67
68
69
70
 
# File 'app/models/work.rb', line 65

def state=(new_state)
  new_state_sym = new_state.to_sym
  valid_states = self.class.aasm.states.map(&:name)
  raise(StandardError, "Invalid state '#{new_state}'") unless valid_states.include?(new_state_sym)
  aasm_write_state_without_persistence(new_state_sym)
end

#submitted_by?(user) ⇒ Boolean

Returns:

  • (Boolean) 


92
93
94
 
# File 'app/models/work.rb', line 92

def submitted_by?(user)
  created_by_user_id == user.id
end

#title ⇒ Object 



159
160
161
 
# File 'app/models/work.rb', line 159

def title
  resource.main_title
end

#total_file_size ⇒ Object

rubocop:enable Metrics/MethodLength



373
374
375
376
377
378
379
 
# File 'app/models/work.rb', line 373

def total_file_size
  total_size = 0
  file_list.each do |file|
    total_size += file[:size]
  end
  total_size
end

#total_file_size_from_list(files) ⇒ Object

Calculates the total file size from a given list of files This is so that we don’t fetch the list twice from AWS since it can be expensive when there are thousands of files on the work.



384
385
386
 
# File 'app/models/work.rb', line 384

def total_file_size_from_list(files)
  files.sum { |file| file[:size] }
end

#track_change(action, filename) ⇒ Object 



522
523
524
 
# File 'app/models/work.rb', line 522

def track_change(action, filename)
  changes << { action:, filename: }
end

#update_curator(curator_user_id, current_user) ⇒ Object 



246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'app/models/work.rb', line 246

def update_curator(curator_user_id, current_user)
  # Update the curator on the Work
  self.curator_user_id = curator_user_id
  save!

  # ...and log the activity
  new_curator = User.find(curator_user_id)

  work_url = "[#{title}](#{Rails.application.routes.url_helpers.work_url(self)})"

  # Troubleshooting https://github.com/pulibrary/pdc_describe/issues/1783
  if work_url.include?("/describe/describe/")
    Rails.logger.error("URL #{work_url} included /describe/describe/ and was fixed. See https://github.com/pulibrary/pdc_describe/issues/1783")
    work_url = work_url.gsub("/describe/describe/", "/describe/")
  end

  message = if curator_user_id.to_i == current_user.id
              "Self-assigned @#{current_user.uid} as curator for work #{work_url}"
            else
              "Set curator to @#{new_curator.uid} for work #{work_url}"
            end
  WorkActivity.add_work_activity(id, message, current_user.id, activity_type: WorkActivity::SYSTEM)
end

#uploads ⇒ Array<S3File>

Retrieve the S3 file uploads associated with the Work

Returns:



330
331
332
333
334
 
# File 'app/models/work.rb', line 330

def uploads
  return post_curation_uploads if approved?

  pre_curation_uploads
end

#uploads_attributes ⇒ Object 



163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'app/models/work.rb', line 163

def uploads_attributes
  return [] if approved? # once approved we no longer allow the updating of uploads via the application
  uploads.map do |upload|
    {
      id: upload.id,
      key: upload.key,
      filename: upload.filename.to_s,
      created_at: upload.created_at,
      url: upload.url
    }
  end
end

#url ⇒ Object 



211
212
213
214
215
 
# File 'app/models/work.rb', line 211

def url
  return unless persisted?

  @url ||= url_for(self)
end