Module: Ddr::Models::FileManagement

Extended by:
ActiveSupport::Concern
Included in:
Base
Defined in:
lib/ddr/models/file_management.rb

Defined Under Namespace

Classes: FileToAdd

Constant Summary collapse

EXTERNAL_FILE_PERMISSIONS = 
0644

Instance Method Summary collapse

Instance Method Details

#add_external_datastream(dsid, opts = {}) ⇒ Object 



124
125
126
127
128
129
130
 
# File 'lib/ddr/models/file_management.rb', line 124

def add_external_datastream dsid, opts={}
  klass = self.class.datastream_class_for_name(dsid)
  datastream = create_datastream(klass, dsid, controlGroup: "E")
  add_datastream(datastream)
  self.class.build_datastream_accessor(dsid)
  datastream
end

#add_external_file(file, dsid, opts = {}) ⇒ Object

Normally this method should not be called directly. Call ‘add_file` with dsid for external datastream id, or with `:external=>true` option if no spec for dsid.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/ddr/models/file_management.rb', line 62

def add_external_file file, dsid, opts={}
  file_path = Ddr::Utils.file_path(file) # raises ArgumentError

  # Retrieve or create the datastream
  ds = datastreams.include?(dsid) ? datastreams[dsid] : add_external_datastream(dsid)

  unless ds.external?
    raise ArgumentError, "Cannot add external file to datastream with controlGroup \"#{ds.controlGroup}\""
  end

  if ds.dsLocation_changed?
    raise Ddr::Models::Error, "Cannot add external file to datastream when dsLocation change is pending."
  end

  # Set the MIME type
  # The :mime_type option will be present when called from `add_file`.
  # The fallback is there in case `add_external_file` is called directly.
  ds.mimeType = opts[:mime_type] || Ddr::Utils.mime_type_for(file, file_path)

  # Copy the file to storage unless we're using the original
  if opts[:use_original]
    raise Ddr::Models::Error, "Cannot add file to repository that is owned by another user." unless File.owned?(file_path)
    store_path = file_path
  else
    # generate new storage path for file
    store_path = create_external_file_path!(ds)
    # copy the original file to the storage location
    FileUtils.cp file_path, store_path
  end

  # set appropriate permissions on the file
  set_external_file_permissions!(store_path)

  # set dsLocation to file URI for storage path
  ds.dsLocation = Ddr::Utils.path_to_uri(store_path)
end

#add_file(file, dsid, opts = {}) ⇒ Object

add_file(file, dsid, opts={})

Comparable to Hydra::ModelMethods#add_file(file, dsid, file_name)

Options:

:mime_type - Explicit mime type to set (otherwise discerned from file path or name)

:original_name - A String value will be understood as the original name of the file.
                 `false` or `nil` indicate that the file basename is not the original
                 name. Default processing will take the file basename as the original
                 name.

:external - Add to file to external datastream. Not required for datastream specs
            where :control_group=>"E".

:use_original - For external datastream file, do not copy file to new file path,
                but use in place (set dsLocation to file URI for current path.



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/ddr/models/file_management.rb', line 39

def add_file file, dsid, opts={}
  opts[:mime_type] ||= Ddr::Utils.mime_type_for(file)

  # @file_to_add is set for callbacks to access the data
  original_name = opts.fetch(:original_name, Ddr::Utils.file_name_for(file))
  self.file_to_add = FileToAdd.new(file, dsid, original_name)

  run_callbacks(:add_file) do
    if opts.delete(:external) || datastreams.include?(dsid) && datastreams[dsid].external?
      add_external_file(file, dsid, opts)
    else
      file = File.new(file, "rb") if Ddr::Utils.file_path?(file)
      # ActiveFedora method accepts file-like objects, not paths
      add_file_datastream(file, dsid: dsid, mimeType: opts[:mime_type])
    end
  end

  # clear the instance data
  self.file_to_add = nil
end

#create_external_file_path!(ds) ⇒ Object

Create directory (if necessary) for newly generated file path and return path



100
101
102
103
104
 
# File 'lib/ddr/models/file_management.rb', line 100

def create_external_file_path! ds
  file_path = generate_external_file_path(ds)
  FileUtils.mkdir_p(File.dirname(file_path))
  file_path
end

#external_datastream_file_paths ⇒ Object 



120
121
122
 
# File 'lib/ddr/models/file_management.rb', line 120

def external_datastream_file_paths
  external_datastreams.map(&:file_paths).flatten
end

#external_datastreams ⇒ Object 



116
117
118
 
# File 'lib/ddr/models/file_management.rb', line 116

def external_datastreams
  datastreams.values.select { |ds| ds.external? }
end

#generate_external_file_path(ds) ⇒ Object

Generates a new external file storage location

> #external_file_store/1/e/69/1e691815-0631-4f9b-8e23-2dfb2eec9c70



111
112
113
114
 
# File 'lib/ddr/models/file_management.rb', line 111

def generate_external_file_path ds
  file_name = generate_external_file_name(ds)
  File.join(external_file_store(ds.dsid), generate_external_directory_subpath, file_name)
end