Class: Dataverse::Dataset

Inherits:
Base
  • Object
show all
Defined in:
lib/dataverse/dataset.rb

Constant Summary collapse

MD_TYPES_XML = 
['ddi', 'oai_ddi', 'dcterms', 'oai_dc', 'Datacite', 'oai_datacite']
MD_TYPES_JSON = 
['schema.org', 'OAI_ORE', 'dataverse_json']
MD_TYPES = 
['rdm', 'raw'] + MD_TYPES_JSON + MD_TYPES_XML

Instance Attribute Summary collapse

Attributes inherited from Base

#api_data

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#==, #eql?, #hash, #refresh

Instance Attribute Details

#id ⇒ Object (readonly)

Returns the value of attribute id.



8
9
10
 
# File 'lib/dataverse/dataset.rb', line 8

def id
  @id
end

Class Method Details

.create(data:, dataverse:) ⇒ Object 



19
20
21
 
# File 'lib/dataverse/dataset.rb', line 19

def self.create(data:, dataverse:)
  new_dataset(dataverse, data)
end

.id(id) ⇒ Object 



10
11
12
 
# File 'lib/dataverse/dataset.rb', line 10

def self.id(id)
  Dataset.new(id)
end

.import(data:, dataverse:, pid:, publish: false, ddi: false) ⇒ Object 



23
24
25
 
# File 'lib/dataverse/dataset.rb', line 23

def self.import(data:, dataverse:, pid:, publish: false, ddi: false)
  new_dataset(dataverse, data, import: pid, publish: publish, ddi: ddi)
end

.pid(pid) ⇒ Object 



14
15
16
17
 
# File 'lib/dataverse/dataset.rb', line 14

def self.pid(pid)
  data = api_call('datasets/:persistentId', params: {'persistentId' => pid})
  Dataset.new(data['id'])
end

Instance Method Details

#author(version: :latest) ⇒ Object 



95
96
97
 
# File 'lib/dataverse/dataset.rb', line 95

def author(version: :latest)
  metadata(version: version).fetch('author').first.fetch('authorName')
end

#call(url, **args) ⇒ Object 



55
56
57
 
# File 'lib/dataverse/dataset.rb', line 55

def call(url, **args)
  api_call("datasets/#{id}/#{url}", **args)
end

#created(version: :latest) ⇒ Object 



103
104
105
 
# File 'lib/dataverse/dataset.rb', line 103

def created(version: :latest)
  Time.parse(version_data(version).fetch('createTime')).getlocal
end

#delete ⇒ Object 



27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/dataverse/dataset.rb', line 27

def delete
  raise Error.new 'Can only delete draft version' unless draft_version
  versions
  result = call('versions/:draft', method: :delete)
  @version_data.delete(:draft)
  @metadata.delete(:draft)
  @files.delete(:draft)
  @version_numbers&.delete(:draft)
  init({}) if published_versions.empty?
  result['message']
end

#download(filename = 'dataverse_files.zip', version: nil) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/dataverse/dataset.rb', line 173

def download(filename = 'dataverse_files.zip', version: nil)
  if version
    v = version_string(version)
    raise Error.new("Version '#{version}' does not exist") unless v
    version = v
  end
  File.open(filename, 'w') do |f|
    size = 0
    block = proc do |response|
      response.value
      response.read_body do |chunk|
        size += chunk.size
        f.write chunk
      end
    rescue Net::HTTPServerException
      return false
    end
    url = 'access/dataset/:persistentId'
    url += "/versions/#{version}" if version
    params = {persistentId: pid}
    api_call(url, params: params, block: block)
    f.close
    size
  end
end

#download_size(version: :latest) ⇒ Object 



168
169
170
171
 
# File 'lib/dataverse/dataset.rb', line 168

def download_size(version: :latest)
  data = call("versions/#{version_string(version)}/downloadsize")
  data['message'][/[,\d]+/].delete(',').to_i
end

#draft_version ⇒ Object 



76
77
78
 
# File 'lib/dataverse/dataset.rb', line 76

def draft_version
  return :draft if @version_data.keys.include?(:draft)
end

#export_metadata(md_type) ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/dataverse/dataset.rb', line 120

def export_metadata(md_type)
  return nil unless version(:published)
  format = case md_type.to_s
  when *MD_TYPES_XML
    :xml
  when *MD_TYPES_JSON
    :json
  when 'rdm'
    return rdm_data
  when 'raw'
    return raw_data
  else
    raise Error.new("Unknown metadata format: '#{md_type}'")
  end
  api_call('datasets/export', params: {exporter: md_type, persistentId: pid}, format: format)
end

#files(version: :latest) ⇒ Object 



164
165
166
 
# File 'lib/dataverse/dataset.rb', line 164

def files(version: :latest)
  @files[resolve_version(version)] || []
end

#metadata(version: :latest) ⇒ Object 



160
161
162
 
# File 'lib/dataverse/dataset.rb', line 160

def metadata(version: :latest)
  @metadata[resolve_version(version)] || {}
end

#metadata_fields(version: :latest) ⇒ Object 



112
113
114
 
# File 'lib/dataverse/dataset.rb', line 112

def metadata_fields(version: :latest)
  metadata(version: version)&.keys || []
end

#pid(version: :latest) ⇒ Object 



59
60
61
 
# File 'lib/dataverse/dataset.rb', line 59

def pid(version: :latest)
  version_data(version).fetch('datasetPersistentId')
end

#publish(major: true) ⇒ Object 



47
48
49
50
51
52
53
 
# File 'lib/dataverse/dataset.rb', line 47

def publish(major: true)
  result = call('actions/:publish', method: :post, 
    params: {type: major ? 'major' : 'minor'}, format: :status
  )
  return "Dataset #{pid} published" if result == 200
  return "Dataset #{pid} waiting for review" if result == 202
end

#published(version: :published) ⇒ Object 



107
108
109
110
 
# File 'lib/dataverse/dataset.rb', line 107

def published(version: :published)
  return nil unless version_data(version).has_key?('releaseTime')
  Time.parse(version_data(version).fetch('releaseTime')).getlocal
end

#published_versions ⇒ Object 



80
81
82
83
84
85
 
# File 'lib/dataverse/dataset.rb', line 80

def published_versions
  @published_versions ||= call('versions').map do |x|
    next unless x['versionState'] == 'RELEASED'
    "#{x['versionNumber']}.#{x['versionMinorNumber']}".to_f
  end.compact
end

#raw_data(version: :latest, with_files: false) ⇒ Object 



153
154
155
156
157
158
 
# File 'lib/dataverse/dataset.rb', line 153

def raw_data(version: :latest, with_files: false)
  result = api_data.dup.merge(version_data(resolve_version(version)))
  result['metadataBlocks'] = call("/versions/#{version_string(version)}/metadata")
  result['files'] = call("/versions/#{version_string(version)}/files") if with_files
  { 'datasetVersion' => result }
end

#rdm_data(version: :published) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/dataverse/dataset.rb', line 137

def rdm_data(version: :published)
  return nil unless version(version)
  api_data
    .merge(version_data(version))
    .merge('metadata' => metadata(version: version))
    .merge('files' => files(version: version))
    .tap do |h|
      h['license'] ||= {
        'name' => license_spdx(h),
        'label' => license_name(h),
        'uri' => license_url(h),
        'iconUrl' => license_icon(h)
      }
    end
end

#reject(reason) ⇒ Object 



43
44
45
 
# File 'lib/dataverse/dataset.rb', line 43

def reject(reason)
  call('returnToAuthor', method: post, body: reason)
end

#size ⇒ Object 



63
64
65
66
 
# File 'lib/dataverse/dataset.rb', line 63

def size
  data = call("storagesize", params: {includeCached: 'true'})
  data['message'][/[,\d]+/].delete(',').to_i
end

#submit ⇒ Object 



39
40
41
 
# File 'lib/dataverse/dataset.rb', line 39

def submit
  call('submitForReview', method: post)
end

#title(version: :latest) ⇒ Object 



91
92
93
 
# File 'lib/dataverse/dataset.rb', line 91

def title(version: :latest)
  metadata(version: version).fetch('title')
end

#updated(version: :latest) ⇒ Object 



99
100
101
 
# File 'lib/dataverse/dataset.rb', line 99

def updated(version: :latest)
  Time.parse(version_data(version).fetch('lastUpdateTime')).getlocal
end

#version(version = :latest) ⇒ Object 



87
88
89
 
# File 'lib/dataverse/dataset.rb', line 87

def version(version = :latest)
  resolve_version(version, raise_if_not_found: false)
end

#versions ⇒ Object 



68
69
70
71
72
73
74
 
# File 'lib/dataverse/dataset.rb', line 68

def versions
  @version_numbers ||= begin
    data = [:latest, :published] + [draft_version].compact + published_versions
    data.delete(:published) unless published_versions.size > 0
    data
  end
end