def test_connect_from_settings(self, mock_connect):
user_settings = AddonDataverseUserSettings()
user_settings.dataverse_username = '******'
user_settings.dataverse_password = '******'
connection = connect_from_settings(None)
assert_is_none(connection)
connection = connect_from_settings(user_settings)
assert_true(connection)
mock_connect.assert_called_once_with(
user_settings.dataverse_username,
user_settings.dataverse_password,
)
def dataverse_set_config(node_addon, auth, **kwargs):
"""Saves selected Dataverse and dataset to node settings"""
user_settings = node_addon.user_settings
user = auth.user
if user_settings and user_settings.owner != user:
raise HTTPError(http.FORBIDDEN)
try:
assert_clean(request.json)
except AssertionError:
# TODO: Test me!
raise HTTPError(http.NOT_ACCEPTABLE)
alias = request.json.get('dataverse', {}).get('alias')
doi = request.json.get('dataset', {}).get('doi')
if doi is None or alias is None:
return HTTPError(http.BAD_REQUEST)
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, alias)
dataset = client.get_dataset(dataverse, doi)
node_addon.set_folder(dataverse, dataset, auth)
return {'dataverse': dataverse.title, 'dataset': dataset.title}, http.OK
def dataverse_set_config(node_addon, auth, **kwargs):
"""Saves selected Dataverse and dataset to node settings"""
user_settings = node_addon.user_settings
user = auth.user
if user_settings and user_settings.owner != user:
raise HTTPError(http.FORBIDDEN)
try:
assert_clean(request.json)
except AssertionError:
# TODO: Test me!
raise HTTPError(http.NOT_ACCEPTABLE)
alias = request.json.get('dataverse', {}).get('alias')
doi = request.json.get('dataset', {}).get('doi')
if doi is None or alias is None:
return HTTPError(http.BAD_REQUEST)
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, alias)
dataset = client.get_dataset(dataverse, doi)
node_addon.set_folder(dataverse, dataset, auth)
return {'dataverse': dataverse.title, 'dataset': dataset.title}, http.OK
def serialize_settings(node_settings, current_user):
"""View helper that returns a dictionary representation of a
DataverseNodeSettings record. Provides the return value for the
dataverse config endpoints.
"""
user_settings = node_settings.user_settings
user_is_owner = user_settings is not None and (user_settings.owner._primary_key == current_user._primary_key)
current_user_settings = current_user.get_addon("dataverse")
result = {
"nodeHasAuth": node_settings.has_auth,
"userIsOwner": user_is_owner,
"userHasAuth": current_user_settings is not None and current_user_settings.has_auth,
"urls": serialize_urls(node_settings),
}
if node_settings.has_auth:
# Add owner's profile info
result["urls"]["owner"] = web_url_for("profile_view_id", uid=user_settings.owner._primary_key)
result.update({"ownerName": user_settings.owner.fullname, "apiToken": user_settings.api_token})
# Add owner's dataverse settings
connection = client.connect_from_settings(user_settings)
dataverses = client.get_dataverses(connection)
result.update(
{
"connected": connection is not None,
"dataverses": [{"title": dataverse.title, "alias": dataverse.alias} for dataverse in dataverses],
"savedDataverse": {"title": node_settings.dataverse, "alias": node_settings.dataverse_alias},
"savedDataset": {"title": node_settings.dataset, "doi": node_settings.dataset_doi},
}
)
return result
def test_connect_from_settings(self, mock_connect):
user_settings = AddonDataverseUserSettings()
user_settings.api_token = 'Something ridiculous'
connection = connect_from_settings(user_settings)
assert_true(connection)
mock_connect.assert_called_once_with(user_settings.api_token)
def serialized_node_settings(self):
result = super(DataverseSerializer, self).serialized_node_settings
result['hosts'] = DEFAULT_HOSTS
# Update with Dataverse specific fields
if self.node_settings.has_auth:
external_account = self.node_settings.external_account
dataverse_host = external_account.oauth_key
connection = client.connect_from_settings(self.node_settings)
dataverses = client.get_dataverses(connection)
result.update({
'dataverseHost': dataverse_host,
'connected': connection is not None,
'dataverses': [
{'title': dataverse.title, 'alias': dataverse.alias}
for dataverse in dataverses
],
'savedDataverse': {
'title': self.node_settings.dataverse,
'alias': self.node_settings.dataverse_alias,
},
'savedDataset': {
'title': self.node_settings.dataset,
'doi': self.node_settings.dataset_doi,
}
})
return result
def test_connect_from_settings(self, mock_connect):
user_settings = AddonDataverseUserSettings()
user_settings.api_token = "Something ridiculous"
connection = connect_from_settings(user_settings)
assert_true(connection)
mock_connect.assert_called_once_with(user_settings.api_token)
def serialized_node_settings(self):
result = super(DataverseSerializer, self).serialized_node_settings
result['hosts'] = DEFAULT_HOSTS
# Update with Dataverse specific fields
if self.node_settings.has_auth:
external_account = self.node_settings.external_account
dataverse_host = external_account.oauth_key
connection = client.connect_from_settings(self.node_settings)
dataverses = client.get_dataverses(connection)
result.update({
'dataverseHost':
dataverse_host,
'connected':
connection is not None,
'dataverses': [{
'title': dataverse.title,
'alias': dataverse.alias
} for dataverse in dataverses],
'savedDataverse': {
'title': self.node_settings.dataverse,
'alias': self.node_settings.dataverse_alias,
},
'savedDataset': {
'title': self.node_settings.dataset,
'doi': self.node_settings.dataset_doi,
}
})
return result
def dataverse_hgrid_root(node_addon, auth, **kwargs):
node = node_addon.owner
user_settings = node_addon.user_settings
default_version = 'latest-published'
version = 'latest-published' if not node.can_edit(auth) else default_version
# Quit if no dataset linked
if not node_addon.complete:
return []
can_edit = node.can_edit(auth)
permissions = {
'edit': can_edit and not node.is_registration,
'view': node.can_view(auth)
}
try:
connection = connect_from_settings(user_settings)
dataverse = get_dataverse(connection, node_addon.dataverse_alias)
dataset = get_dataset(dataverse, node_addon.dataset_doi)
except SSLError:
return [rubeus.build_addon_root(
node_addon,
node_addon.dataset,
permissions=permissions
)]
# Quit if doi does not produce a dataset
if dataset is None:
return []
published_files = get_files(dataset, published=True)
# Produce draft version or quit if no published version is available
if not published_files:
if can_edit:
version = 'latest'
else:
return []
urls = {
'publish': node.api_url_for('dataverse_publish_dataset'),
'publishBoth': node.api_url_for('dataverse_publish_both')
}
return [rubeus.build_addon_root(
node_addon,
node_addon.dataset,
urls=urls,
permissions=permissions,
dataset=node_addon.dataset,
doi=dataset.doi,
dataverse=dataverse.title,
hasPublishedFiles=bool(published_files),
dataverseIsPublished=dataverse.is_published,
version=version,
)]
def test_connect_from_settings(self, mock_connect):
node_settings = AddonDataverseNodeSettings()
node_settings.external_account = create_external_account(
self.host, self.token,
)
connection = connect_from_settings(node_settings)
assert_true(connection)
mock_connect.assert_called_once_with(self.host, self.token)
def dataverse_get_datasets(node_addon, **kwargs):
alias = request.json.get("alias")
user_settings = node_addon.user_settings
connection = client.connect_from_settings(user_settings)
dataverse = client.get_dataverse(connection, alias)
datasets = client.get_datasets(dataverse)
ret = {"datasets": [{"title": dataset.title, "doi": dataset.doi} for dataset in datasets]}
return ret, http.OK
def test_connect_from_settings(self, mock_connect):
node_settings = AddonDataverseNodeSettings()
node_settings.external_account = create_external_account(
self.host, self.token,
)
connection = connect_from_settings(node_settings)
assert_true(connection)
mock_connect.assert_called_once_with(self.host, self.token)
def dataverse_get_datasets(node_addon, **kwargs):
"""Get list of datasets from provided Dataverse alias"""
alias = request.json.get('alias')
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, alias)
datasets = client.get_datasets(dataverse)
ret = {
'alias': alias, # include alias to verify dataset container
'datasets': [{'title': dataset.title, 'doi': dataset.doi} for dataset in datasets],
}
return ret, http.OK
def dataverse_get_datasets(node_addon, **kwargs):
"""Get list of datasets from provided Dataverse alias"""
alias = request.json.get('alias')
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, alias)
datasets = client.get_datasets(dataverse)
ret = {
'alias': alias, # include alias to verify dataset container
'datasets': [{'title': dataset.title, 'doi': dataset.doi} for dataset in datasets],
}
return ret, http.OK
def dataverse_hgrid_data_contents(node_addon, auth, **kwargs):
node = node_addon.owner
user_settings = node_addon.user_settings
state = request.args.get('state')
default_state = 'released'
state = 'released' if not node.can_edit(auth) else state or default_state
released = state == 'released'
can_edit = node.can_edit(auth) and not node.is_registration and not released
can_view = node.can_view(auth)
connection = connect_from_settings(user_settings)
if node_addon.study_hdl is None or connection is None:
return []
dataverse = get_dataverse(connection, node_addon.dataverse_alias)
study = get_study(dataverse, node_addon.study_hdl)
# Quit if hdl does not produce a study
if study is None:
return []
info = []
for f in get_files(study, released):
item = {
'addon': 'dataverse',
'provider': 'dataverse',
rubeus.KIND: 'file',
'name': f.name,
'path': f.name,
'file_id': f.id,
'ext': os.path.splitext(f.name)[1],
'urls': {
'view': node.web_url_for('dataverse_view_file',
path=f.id),
'download': node.web_url_for('dataverse_download_file',
path=f.id),
'delete': node.api_url_for('dataverse_delete_file',
path=f.id),
},
'permissions': {
'view': can_view,
'edit': can_edit,
},
}
info.append(item)
return {'data': info}
def dataverse_hgrid_data_contents(node_addon, auth, **kwargs):
node = node_addon.owner
user_settings = node_addon.user_settings
state = request.args.get('state')
default_state = 'released'
state = 'released' if not node.can_edit(auth) else state or default_state
released = state == 'released'
can_edit = node.can_edit(
auth) and not node.is_registration and not released
can_view = node.can_view(auth)
connection = connect_from_settings(user_settings)
if node_addon.study_hdl is None or connection is None:
return []
dataverse = get_dataverse(connection, node_addon.dataverse_alias)
study = get_study(dataverse, node_addon.study_hdl)
# Quit if hdl does not produce a study
if study is None:
return []
info = []
for f in get_files(study, released):
item = {
'addon': 'dataverse',
'provider': 'dataverse',
rubeus.KIND: 'file',
'name': f.name,
'path': f.name,
'file_id': f.id,
'ext': os.path.splitext(f.name)[1],
'urls': {
'view': node.web_url_for('dataverse_view_file', path=f.id),
'download': node.web_url_for('dataverse_download_file',
path=f.id),
'delete': node.api_url_for('dataverse_delete_file', path=f.id),
},
'permissions': {
'view': can_view,
'edit': can_edit,
},
}
info.append(item)
return {'data': info}
def dataverse_get_studies(node_addon, **kwargs):
alias = request.json.get('alias')
user_settings = node_addon.user_settings
connection = connect_from_settings(user_settings)
dataverse = get_dataverse(connection, alias)
studies, bad_studies = get_studies(dataverse)
rv = {
'studies': [{'title': study.title, 'hdl': study.doi} for study in studies],
'badStudies': [{'hdl': bad_study.doi, 'url': 'http://dx.doi.org/' + bad_study.doi} for bad_study in bad_studies],
}
code = http.PARTIAL_CONTENT if bad_studies else http.OK
return rv, code
def dataverse_get_studies(node_addon, **kwargs):
alias = request.json.get('alias')
user_settings = node_addon.user_settings
connection = client.connect_from_settings(user_settings)
dataverse = client.get_dataverse(connection, alias)
studies, bad_studies = client.get_studies(dataverse)
ret = {
'studies': [{'title': study.title, 'hdl': study.doi} for study in studies],
'badStudies': [{'hdl': bad_study.doi, 'url': 'http://dx.doi.org/' + bad_study.doi} for bad_study in bad_studies],
}
code = http.PARTIAL_CONTENT if bad_studies else http.OK
return ret, code
def dataverse_get_datasets(node_addon, **kwargs):
alias = request.json.get('alias')
user_settings = node_addon.user_settings
connection = client.connect_from_settings(user_settings)
dataverse = client.get_dataverse(connection, alias)
datasets = client.get_datasets(dataverse)
ret = {
'datasets': [{
'title': dataset.title,
'doi': dataset.doi
} for dataset in datasets],
}
return ret, http.OK
def serialize_settings(node_settings, current_user):
"""View helper that returns a dictionary representation of a
DataverseNodeSettings record. Provides the return value for the
dataverse config endpoints.
"""
user_settings = node_settings.user_settings
user_is_owner = user_settings is not None and (
user_settings.owner._primary_key == current_user._primary_key)
current_user_settings = current_user.get_addon('dataverse')
result = {
'nodeHasAuth':
node_settings.has_auth,
'userIsOwner':
user_is_owner,
'userHasAuth':
current_user_settings is not None and current_user_settings.has_auth,
'urls':
serialize_urls(node_settings),
}
if node_settings.has_auth:
# Add owner's profile info
result['urls']['owner'] = web_url_for(
'profile_view_id', uid=user_settings.owner._primary_key)
result.update({
'ownerName': user_settings.owner.fullname,
'dataverseUsername': user_settings.dataverse_username,
})
# Add owner's dataverse settings
connection = client.connect_from_settings(user_settings)
dataverses = client.get_dataverses(connection)
result.update({
'connected':
connection is not None,
'dataverses': [{
'title': dataverse.title,
'alias': dataverse.alias
} for dataverse in dataverses],
'savedDataverse': {
'title': node_settings.dataverse,
'alias': node_settings.dataverse_alias
},
'savedStudy': {
'title': node_settings.study,
'hdl': node_settings.study_hdl
}
})
return result
def dataverse_set_config(node_addon, auth, **kwargs):
"""Saves selected Dataverse and dataset to node settings"""
user_settings = node_addon.user_settings
user = auth.user
if user_settings and user_settings.owner != user:
raise HTTPError(http.FORBIDDEN)
try:
assert_clean(request.json)
except AssertionError:
# TODO: Test me!
raise HTTPError(http.NOT_ACCEPTABLE)
alias = request.json.get('dataverse').get('alias')
doi = request.json.get('dataset').get('doi')
if doi is None:
return HTTPError(http.BAD_REQUEST)
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, alias)
dataset = client.get_dataset(dataverse, doi)
node_addon.dataverse_alias = dataverse.alias
node_addon.dataverse = dataverse.title
node_addon.dataset_doi = dataset.doi
node_addon.dataset_id = dataset.id
node_addon.dataset = dataset.title
node = node_addon.owner
node.add_log(
action='dataverse_dataset_linked',
params={
'project': node.parent_id,
'node': node._primary_key,
'dataset': dataset.title,
},
auth=auth,
)
node_addon.save()
return {'dataverse': dataverse.title, 'dataset': dataset.title}, http.OK
def dataverse_set_config(node_addon, auth, **kwargs):
"""Saves selected Dataverse and dataset to node settings"""
user_settings = node_addon.user_settings
user = auth.user
if user_settings and user_settings.owner != user:
raise HTTPError(http.FORBIDDEN)
try:
assert_clean(request.json)
except AssertionError:
# TODO: Test me!
raise HTTPError(http.NOT_ACCEPTABLE)
alias = request.json.get('dataverse').get('alias')
doi = request.json.get('dataset').get('doi')
if doi is None:
return HTTPError(http.BAD_REQUEST)
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, alias)
dataset = client.get_dataset(dataverse, doi)
node_addon.dataverse_alias = dataverse.alias
node_addon.dataverse = dataverse.title
node_addon.dataset_doi = dataset.doi
node_addon.dataset_id = dataset.id
node_addon.dataset = dataset.title
node = node_addon.owner
node.add_log(
action='dataverse_dataset_linked',
params={
'project': node.parent_id,
'node': node._primary_key,
'dataset': dataset.title,
},
auth=auth,
)
node_addon.save()
return {'dataverse': dataverse.title, 'dataset': dataset.title}, http.OK
def set_dataverse_and_study(node_addon, auth, **kwargs):
user_settings = node_addon.user_settings
user = get_current_user()
if user_settings and user_settings.owner != user:
raise HTTPError(http.FORBIDDEN)
try:
assert_clean(request.json)
except AssertionError:
# TODO: Test me!
raise HTTPError(http.NOT_ACCEPTABLE)
alias = request.json.get('dataverse').get('alias')
hdl = request.json.get('study').get('hdl')
if hdl is None:
return HTTPError(http.BAD_REQUEST)
connection = connect_from_settings(user_settings)
dataverse = get_dataverse(connection, alias)
study = get_study(dataverse, hdl)
node_addon.dataverse_alias = dataverse.alias
node_addon.dataverse = dataverse.title
node_addon.study_hdl = study.doi
node_addon.study = study.title
node = node_addon.owner
node.add_log(
action='dataverse_study_linked',
params={
'project': node.parent_id,
'node': node._primary_key,
'study': study.title,
},
auth=auth,
)
node_addon.save()
return {'dataverse': dataverse.title, 'study': study.title}, http.OK
def set_dataverse_and_study(node_addon, auth, **kwargs):
user_settings = node_addon.user_settings
user = auth.user
if user_settings and user_settings.owner != user:
raise HTTPError(http.FORBIDDEN)
try:
assert_clean(request.json)
except AssertionError:
# TODO: Test me!
raise HTTPError(http.NOT_ACCEPTABLE)
alias = request.json.get('dataverse').get('alias')
hdl = request.json.get('study').get('hdl')
if hdl is None:
return HTTPError(http.BAD_REQUEST)
connection = client.connect_from_settings(user_settings)
dataverse = client.get_dataverse(connection, alias)
study = client.get_study(dataverse, hdl)
node_addon.dataverse_alias = dataverse.alias
node_addon.dataverse = dataverse.title
node_addon.study_hdl = study.doi
node_addon.study = study.title
node = node_addon.owner
node.add_log(
action='dataverse_study_linked',
params={
'project': node.parent_id,
'node': node._primary_key,
'study': study.title,
},
auth=auth,
)
node_addon.save()
return {'dataverse': dataverse.title, 'study': study.title}, http.OK
def serialize_settings(node_settings, current_user):
"""View helper that returns a dictionary representation of a
DataverseNodeSettings record. Provides the return value for the
dataverse config endpoints.
"""
user_settings = node_settings.user_settings
user_is_owner = user_settings is not None and (
user_settings.owner._primary_key == current_user._primary_key
)
current_user_settings = current_user.get_addon('dataverse')
result = {
'nodeHasAuth': node_settings.has_auth,
'userIsOwner': user_is_owner,
'userHasAuth': current_user_settings is not None and current_user_settings.has_auth,
'urls': serialize_urls(node_settings),
}
if node_settings.has_auth:
# Add owner's profile info
result['urls']['owner'] = web_url_for('profile_view_id',
uid=user_settings.owner._primary_key)
result.update({
'ownerName': user_settings.owner.fullname,
'dataverseUsername': user_settings.dataverse_username,
})
# Add owner's dataverse settings
connection = connect_from_settings(user_settings)
dataverses = get_dataverses(connection)
result.update({
'connected': connection is not None,
'dataverses': [
{'title': dataverse.title, 'alias': dataverse.alias}
for dataverse in dataverses
],
'savedDataverse': {
'title': node_settings.dataverse,
'alias': node_settings.dataverse_alias
},
'savedStudy': {
'title': node_settings.study,
'hdl': node_settings.study_hdl
}
})
return result
def set_dataverse_and_dataset(node_addon, auth, **kwargs):
user_settings = node_addon.user_settings
user = auth.user
if user_settings and user_settings.owner != user:
raise HTTPError(http.FORBIDDEN)
try:
assert_clean(request.json)
except AssertionError:
# TODO: Test me!
raise HTTPError(http.NOT_ACCEPTABLE)
alias = request.json.get("dataverse").get("alias")
doi = request.json.get("dataset").get("doi")
if doi is None:
return HTTPError(http.BAD_REQUEST)
connection = client.connect_from_settings(user_settings)
dataverse = client.get_dataverse(connection, alias)
dataset = client.get_dataset(dataverse, doi)
node_addon.dataverse_alias = dataverse.alias
node_addon.dataverse = dataverse.title
node_addon.dataset_doi = dataset.doi
node_addon.dataset_id = dataset.id
node_addon.dataset = dataset.title
node = node_addon.owner
node.add_log(
action="dataverse_dataset_linked",
params={"project": node.parent_id, "node": node._primary_key, "dataset": dataset.title},
auth=auth,
)
node_addon.save()
return {"dataverse": dataverse.title, "dataset": dataset.title}, http.OK
def test_connect_from_settings_none(self):
connection = connect_from_settings(None)
assert_is_none(connection)
def test_connect_from_settings_none(self):
connection = connect_from_settings(None)
assert_is_none(connection)
def dataverse_hgrid_root(node_addon, auth, state=None, **kwargs):
node = node_addon.owner
user_settings = node_addon.user_settings
default_state = 'released'
state = 'released' if not node.can_edit(auth) else state or default_state
connection = connect_from_settings(user_settings)
# Quit if no study linked
if node_addon.study_hdl is None or connection is None:
return []
dataverse = get_dataverse(connection, node_addon.dataverse_alias)
study = get_study(dataverse, node_addon.study_hdl)
# Quit if hdl does not produce a study
if study is None:
return []
released_files = get_files(study, released=True)
authorized = node.can_edit(auth)
# Produce draft version or quit if no released version is available
if not released_files:
if authorized:
state = 'draft'
else:
return []
study_name = node_addon.study
if len(study_name) > 23:
study_name = u'{0}...'.format(study_name[:20])
permissions = {
'edit': node.can_edit(auth) and not node.is_registration,
'view': node.can_view(auth)
}
urls = {
'upload': node.api_url_for('dataverse_upload_file'),
'fetch': node.api_url_for('dataverse_hgrid_data_contents',
state=state),
'state': node.api_url_for('dataverse_root_folder_public'),
'release': node.api_url_for('dataverse_release_study'),
}
buttons = [
rubeus.build_addon_button('<i class="fa fa-globe"></i> Release Study',
'releaseStudy')
] if state == 'draft' else None
return [
rubeus.build_addon_root(
node_addon,
study_name,
urls=urls,
permissions=permissions,
buttons=buttons,
study=study_name,
doi=study.doi,
dataverse=dataverse.title,
citation=study.citation,
hasReleasedFiles=bool(released_files),
state=state,
)
]
def _dataverse_root_folder(node_addon, auth, **kwargs):
node = node_addon.owner
default_version = 'latest-published'
version = 'latest-published' if not node.can_edit(auth) else default_version
# Quit if no dataset linked
if not node_addon.complete:
return []
can_edit = node.can_edit(auth)
permissions = {
'edit': can_edit and not node.is_registration,
'view': node.can_view(auth)
}
try:
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, node_addon.dataverse_alias)
dataset = client.get_dataset(dataverse, node_addon.dataset_doi)
except SSLError:
return [rubeus.build_addon_root(
node_addon,
node_addon.dataset,
permissions=permissions,
private_key=kwargs.get('view_only', None),
)]
# Quit if doi does not produce a dataset
if dataset is None:
return []
published_files = client.get_files(dataset, published=True)
# Produce draft version or quit if no published version is available
if not published_files:
if can_edit:
version = 'latest'
else:
return []
urls = {
'publish': node.api_url_for('dataverse_publish_dataset'),
}
# determine if there are any changes between the published and draft
# versions of the dataset
try:
dataset.get_metadata('latest-published')
dataset_is_published = True
dataset_draft_modified = dataset.get_state() == 'DRAFT'
except VersionJsonNotFoundError:
dataset_is_published = False
dataset_draft_modified = True
# Get the dataverse host
# (stored in oauth_key because dataverse doesn't use that)
dataverse_host = node_addon.external_account.oauth_key
return [rubeus.build_addon_root(
node_addon,
node_addon.dataset,
urls=urls,
permissions=permissions,
dataset=node_addon.dataset,
doi=dataset.doi,
dataverse=dataverse.title,
hasPublishedFiles=bool(published_files),
dataverseIsPublished=dataverse.is_published,
datasetIsPublished=dataset_is_published,
datasetDraftModified=dataset_draft_modified,
version=version,
host=dataverse_host,
private_key=kwargs.get('view_only', None),
)]
def dataverse_hgrid_root(node_addon, auth, state=None, **kwargs):
node = node_addon.owner
user_settings = node_addon.user_settings
default_state = 'released'
state = 'released' if not node.can_edit(auth) else state or default_state
connection = connect_from_settings(user_settings)
# Quit if no study linked
if node_addon.study_hdl is None or connection is None:
return []
dataverse = get_dataverse(connection, node_addon.dataverse_alias)
study = get_study(dataverse, node_addon.study_hdl)
# Quit if hdl does not produce a study
if study is None:
return []
released_files = get_files(study, released=True)
authorized = node.can_edit(auth)
# Produce draft version or quit if no released version is available
if not released_files:
if authorized:
state = 'draft'
else:
return []
study_name = node_addon.study
if len(study_name) > 23:
study_name = u'{0}...'.format(study_name[:20])
permissions = {
'edit': node.can_edit(auth) and not node.is_registration,
'view': node.can_view(auth)
}
urls = {
'upload': node.api_url_for('dataverse_upload_file'),
'fetch': node.api_url_for('dataverse_hgrid_data_contents', state=state),
'state': node.api_url_for('dataverse_root_folder_public'),
'release': node.api_url_for('dataverse_release_study'),
}
buttons = [rubeus.build_addon_button(
'<i class="fa fa-globe"></i> Release Study',
'releaseStudy')] if state == 'draft' else None
return [rubeus.build_addon_root(
node_addon,
study_name,
urls=urls,
permissions=permissions,
buttons=buttons,
study=study_name,
doi=study.doi,
dataverse=dataverse.title,
citation=study.citation,
hasReleasedFiles=bool(released_files),
state=state,
)]
def _dataverse_root_folder(node_addon, auth, **kwargs):
node = node_addon.owner
default_version = 'latest-published'
version = 'latest-published' if not node.can_edit(auth) else default_version
# Quit if no dataset linked
if not node_addon.complete:
return []
can_edit = node.can_edit(auth)
permissions = {
'edit': can_edit and not node.is_registration,
'view': node.can_view(auth)
}
try:
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, node_addon.dataverse_alias)
dataset = client.get_dataset(dataverse, node_addon.dataset_doi)
except SSLError:
return [rubeus.build_addon_root(
node_addon,
node_addon.dataset,
permissions=permissions
)]
# Quit if doi does not produce a dataset
if dataset is None:
return []
published_files = client.get_files(dataset, published=True)
# Produce draft version or quit if no published version is available
if not published_files:
if can_edit:
version = 'latest'
else:
return []
urls = {
'publish': node.api_url_for('dataverse_publish_dataset'),
}
# determine if there are any changes between the published and draft
# versions of the dataset
try:
dataset.get_metadata('latest-published')
dataset_is_published = True
dataset_draft_modified = dataset.get_state() == 'DRAFT'
except VersionJsonNotFoundError:
dataset_is_published = False
dataset_draft_modified = True
# Get the dataverse host
# (stored in oauth_key because dataverse doesn't use that)
dataverse_host = node_addon.external_account.oauth_key
return [rubeus.build_addon_root(
node_addon,
node_addon.dataset,
urls=urls,
permissions=permissions,
dataset=node_addon.dataset,
doi=dataset.doi,
dataverse=dataverse.title,
hasPublishedFiles=bool(published_files),
dataverseIsPublished=dataverse.is_published,
datasetIsPublished=dataset_is_published,
datasetDraftModified=dataset_draft_modified,
version=version,
host=dataverse_host,
)]
