def testHandlesSingleEntry(self):
from ..views import SCHEMA_URI
psm = ParameterSetManager(parentObject=self.experiment,
schema=SCHEMA_URI)
params = {
'type': 'website',
'identifier': 'https://www.google.com/',
'title': 'Google',
'notes': 'This is a note.'
}
for k, v in params.items():
psm.set_param(k, v)
response = self.client.get(
reverse('tardis.apps.related_info.views.' +
'list_or_create_related_info',
args=[self.experiment.id]))
expect(response.status_code).to_equal(200)
expect(response['Content-Type'])\
.to_equal('application/json; charset=utf-8')
objs = json.loads(response.content)
expect(len(objs)).to_be(1)
for k in params.keys():
expect(objs[0][k]).to_equal(params[k])
def testHandlesMultipleEntries(self):
from ..views import SCHEMA_URI
param_list = ({'type': 'website',
'identifier': 'https://www.example.test/%d' % i,
'title': 'Title #%d' % i,
'notes': 'This is note #%d.' % i} for i in range(10))
for params in param_list:
psm = ParameterSetManager(parentObject=self.experiment,
schema=SCHEMA_URI)
for k, v in params.items():
psm.set_param(k, v)
response = self.client.get(
reverse('tardis.apps.related_info.views.'
+ 'list_or_create_related_info',
args=[self.experiment.id]))
expect(response.status_code).to_equal(200)
expect(response['Content-Type'])\
.to_equal('application/json; charset=utf-8')
objs = json.loads(response.content)
expect(len(objs)).to_be(10)
for obj in objs:
expect(obj['type']).to_equal('website')
expect(obj['identifier']).to_match(r'www.example.test/\d+$')
expect(obj['title']).to_match(r'^Title #\d+$')
expect(obj['notes']).to_match(r'note #\d+\.$')
def test_new_parameterset(self):
psm = ParameterSetManager(parentObject=self.datafile,
schema="http://localhost/psmtest/df2/")
self.assertTrue(
psm.get_schema().namespace == "http://localhost/psmtest/df2/")
psm.set_param("newparam1", "test3", "New Parameter 1")
self.assertTrue(psm.get_param("newparam1").string_value == "test3")
self.assertTrue(
psm.get_param("newparam1").name.full_name == "New Parameter 1")
psm.new_param("newparam1", "test4")
self.assertTrue(len(psm.get_params("newparam1", True)) == 2)
psm.set_param_list("newparam2", ("a", "b", "c", "d"))
self.assertTrue(len(psm.get_params("newparam2")) == 4)
psm.set_params_from_dict({"newparam2": "test5", "newparam3": 3})
self.assertTrue(psm.get_param("newparam2", True) == "test5")
# the newparam3 gets created and '3' is set to a string_value
# since once cannot assume that an initial numeric value
# will imply continuing numeric type for this new param
self.assertTrue(psm.get_param("newparam3").string_value == '3')
psm.delete_params("newparam1")
self.assertTrue(len(psm.get_params("newparam1", True)) == 0)
def _create_experiment(user, bad):
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_METADATA
experiment.save()
experiment.author_experiment_set.create(
order=0, author="John Cleese", url="http://nla.gov.au/nla.party-1")
experiment.author_experiment_set.create(
order=1, author="Michael Palin", url="http://nla.gov.au/nla.party-2")
psm = ParameterSetManager(parentObject=experiment, schema=SCHEMA_URI)
if bad:
params = {
'type': 'website',
'identifier': 'https://www.badexample.com/'
}
else:
params = {
'type': 'website',
'identifier': 'https://www.example.com/',
'title': 'Google',
'notes': 'This is a note.'
}
for k, v in params.items():
psm.set_param(k, v)
return experiment
def testHandlesFound(self):
from ..views import SCHEMA_URI
psm = ParameterSetManager(parentObject=self.experiment,
schema=SCHEMA_URI)
params = {'type': 'website',
'identifier': 'https://www.google.com/',
'title': 'Google',
'notes': 'This is a note.'}
for k, v in params.items():
psm.set_param(k, v)
response = self.client.get(
reverse('tardis.apps.related_info.views.' +
'get_or_update_or_delete_related_info',
args=[self.experiment.id, psm.parameterset.id]))
expect(response.status_code).to_equal(200)
obj = json.loads(response.content)
for k, v in params.items():
expect(obj[k]).to_equal(v)
def testHandlesSingleEntry(self):
from ..views import SCHEMA_URI
psm = ParameterSetManager(parentObject=self.experiment,
schema=SCHEMA_URI)
params = {'type': 'website',
'identifier': 'https://www.google.com/',
'title': 'Google',
'notes': 'This is a note.'}
for k, v in params.items():
psm.set_param(k, v)
response = self.client.get(
reverse('tardis.apps.related_info.views.' +
'list_or_create_related_info',
args=[self.experiment.id]))
expect(response.status_code).to_equal(200)
expect(response['Content-Type'])\
.to_equal('application/json; charset=utf-8')
objs = json.loads(response.content)
expect(len(objs)).to_be(1)
for k, v in params.items():
expect(objs[0][k]).to_equal(v)
def test_new_parameterset(self):
psm = ParameterSetManager(parentObject=self.datafile,
schema="http://localhost/psmtest/df2/")
self.assertTrue(psm.get_schema().namespace ==
"http://localhost/psmtest/df2/")
psm.set_param("newparam1", "test3", "New Parameter 1")
self.assertTrue(psm.get_param("newparam1").string_value ==
"test3")
self.assertTrue(psm.get_param("newparam1").name.full_name ==
"New Parameter 1")
psm.new_param("newparam1", "test4")
self.assertTrue(len(psm.get_params("newparam1", True)) == 2)
psm.set_param_list("newparam2", ("a", "b", "c", "d"))
self.assertTrue(len(psm.get_params("newparam2")) == 4)
psm.set_params_from_dict(
{"newparam2": "test5", "newparam3": 3})
self.assertTrue(psm.get_param("newparam2", True) == "test5")
# the newparam3 gets created and '3' is set to a string_value
# since once cannot assume that an initial numeric value
# will imply continuing numeric type for this new param
self.assertTrue(psm.get_param("newparam3").string_value == '3')
psm.delete_params("newparam1")
self.assertTrue(len(psm.get_params("newparam1", True)) == 0)
def save_metadata(self, datafile, schema, metadata):
psm = ParameterSetManager(parentObject=datafile.dataset, schema=schema.namespace)
psm.set_param("metadata-filename", datafile.filename)
for key, value in metadata:
try:
psm.set_param(key, value)
except ValueError, e:
pn = ParameterName.objects.get(name=key, schema=schema)
psm.set_param(key, value.strip(pn.units))
def _create_experiment(user, bad):
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_METADATA
experiment.save()
experiment.experimentauthor_set.create(order=0,
author="John Cleese",
url="http://nla.gov.au/nla.party-1")
experiment.experimentauthor_set.create(order=1,
author="Michael Palin",
url="http://nla.gov.au/nla.party-2")
psm = ParameterSetManager(parentObject=experiment, schema=SCHEMA_URI)
if bad:
params = {'type': 'website',
'identifier': 'https://www.badexample.com/'}
else:
params = {'type': 'website',
'identifier': 'https://www.example.com/',
'title': 'Google',
'notes': 'This is a note.'}
for k, v in params.items():
psm.set_param(k, v)
return experiment
def save_metadata(self, datafile, schema, metadata):
psm = ParameterSetManager(parentObject=datafile.dataset,
schema=schema.namespace)
psm.set_param('metadata-filename', datafile.filename)
for key, value in metadata:
try:
psm.set_param(key, value)
except ValueError, e:
pn = ParameterName.objects.get(name=key, schema=schema)
psm.set_param(key, value.strip(pn.units))
def register(self, request):
"""
Use the EIF038 web services to gather and store party/activity
ids for the linkages required by ANDS Research Data Australia.
:param request: a HTTP Request instance
:type request: :class:`django.http.HttpRequest`
"""
username = request.user.username
pais = PartyActivityInformationService()
pai = pais.get_pai()
monash_id_list = []
experiment = Experiment.objects.get(id=self.experiment_id)
self.clear_existing_parameters(request)
if not('ldap_existing_party' in request.POST or\
'ldap_party' in request.POST):
return {'status': False,
'message': 'Error: Must have at least' +
' one Monash party nominated'}
if 'ldap_existing_party' in request.POST:
for email in request.POST.getlist('ldap_existing_party'):
relation_name = 'exists-' + email + '-relation'
if relation_name in request.POST:
monash_id_list.append(\
{'party_param': email,
'relation_param': request.POST[relation_name]})
# write new party info for existing party
if settings.OAI_DOCS_PATH:
party_rif_cs = pai.get_party_rifcs(email)
XMLWriter.write_xml_to_file(
'rif',
'party',
email,
party_rif_cs
)
message = ""
if 'ldap_party' in request.POST:
fail = False
for email in request.POST.getlist('ldap_party'):
if str(email):
monash_id = ""
try:
l = LDAPUserQuery()
authcate = []
authcate.append([LDAPUserQuery.get_user_attr(u, 'uid')\
for u in \
l.get_authcate_exact(email)])
monash_id = pai.get_unique_party_id(authcate[0][0])
relation_name = 'new-' + email + '-relation'
if relation_name in request.POST:
monash_id_list.append(\
{'party_param': monash_id,
'relation_param': request.POST[relation_name]})
except urllib2.URLError:
fail = True
logger.error("Can't contact research" +
" master web service")
message = message + \
'Error: Cannot contact Activity' + \
' / Party Service. Please try again later.' \
+ "<br/>"
except IndexError:
logger.error("Can't contact ldap for " +
email)
fail = True
error = "Can't get authcate for email address: " + email\
+ "<br/>"
message = message + "<br/>" + error
except KeyError:
logger.error("Couldn't find authcate for " +
email)
fail = True
error = "Can't get authcate for email address: " + email\
+ "<br/>"
message = message + "<br/>" + error
if fail:
return {'status': False,
'message': message}
for monash_id in monash_id_list:
self.save_party_parameter(experiment,
monash_id['party_param'], monash_id['relation_param'])
if settings.OAI_DOCS_PATH:
party_rif_cs = pai.get_party_rifcs(monash_id['party_param'])
XMLWriter.write_xml_to_file(
'rif',
'party',
monash_id['party_param'],
party_rif_cs
)
for activity_id in request.POST.getlist('activity'):
if activity_id in self.get_existing_activity_keys():
pass
else:
self.save_activity_parameter(experiment, activity_id)
if settings.OAI_DOCS_PATH:
activity_rif_cs = pai.get_activity_rifcs(activity_id)
XMLWriter.write_xml_to_file(
'rif',
'activity',
activity_id,
activity_rif_cs
)
cch = CreativeCommonsHandler(experiment_id=experiment.id, create=False)
license_name = ""
if cch.has_cc_license():
psm = cch.get_or_create_cc_parameterset()
license_name = ""
try:
license_name = psm.get_param('license_name', True)
except ExperimentParameter.DoesNotExist:
pass
c = Context(dict({
'now': datetime.datetime.now(),
'experiment': experiment,
'party_keys': monash_id_list,
'activity_keys': request.POST.getlist('activity'),
'site_domain': Site.objects.get_current().domain,
'license_name': license_name,
}))
custom_description = None
if 'custom_description' in request.POST:
custom_description = request.POST['custom_description']
if custom_description:
schema = 'http://localhost/pilot/collection/1.0/'
psm = \
self.get_or_create_parameterset(schema)
psm.set_param("custom_description", custom_description,
"Custom Description For ANDS Research Data Australia")
c['custom_description'] = custom_description
selected_profile = self.get_profile()
if not selected_profile:
selected_profile = "default.xml"
profile_template = "monash_ands/profiles/" + selected_profile
import sys
mas_settings = sys.modules['%s.%s.settings' %
(settings.TARDIS_APP_ROOT, 'monash_ands')]
if mas_settings.HANDLE_ENABLE:
if not experiment.handle:
try:
from HandleService import HandleService
hdlsrv = HandleService()
response = hdlsrv.mint(
mas_settings.AUTHTYPE, mas_settings.IDENTIFIER,
mas_settings.AUTHDOMAIN, mas_settings.APPID,
mas_settings.MINTURL, \
Site.objects.get_current().domain +\
"/experiment/view/" + str(experiment.id))
from xml.dom import minidom
xmldoc = minidom.parseString(response)
handle = xmldoc.firstChild.childNodes[1].attributes["handle"].value
if handle:
experiment.handle = handle
experiment.save()
except KeyError:
logger.error(response)
logger.error("Persistent handle minting failed")
if settings.OAI_DOCS_PATH:
XMLWriter.write_template_to_file(
'rif',
'collection',
experiment.id,
profile_template,
c,
)
if request.POST['profile']:
profile = request.POST['profile']
self.save_rif_cs_profile(experiment, profile)
else:
return {'status': True,
'message': 'No profiles exist to choose from'}
schema = "http://localhost/pilot/registration_record/1.0/"
psm = ParameterSetManager(schema=schema,
parentObject=experiment)
now = datetime.datetime.now().strftime("%d %B %Y %Y %I:%M%p")
psm.set_param("registration_date", now,
"Registration Date")
psm.set_param("registered_by", request.user.username,
"Registered By")
return {'status': True, 'message': 'Successfully registered experiment.'}
class CreativeCommonsHandler():
psm = None
schema = "http://www.tardis.edu.au/schemas" +\
"/creative_commons/2011/05/17"
experiment_id = None
def __init__(self, experiment_id=experiment_id, create=True):
"""
:param experiment_id: The id of the experiment
:type experiment_id: integer
:param create: If true, creates a new parameterset object to
hold the cc license
:type create: boolean
"""
self.experiment_id = experiment_id
if create:
self.psm = self.get_or_create_cc_parameterset(create=True)
else:
self.psm = self.get_or_create_cc_parameterset(create=False)
def get_or_create_cc_parameterset(self, create=True):
"""
Gets the creative commons parameterset for the experiment
:param create: If true, creates a new parameterset object to
hold the cc license if one doesn't exist
:type create: boolean
:return: The parameterset manager for the cc parameterset
:rtype: :class:`tardis.tardis_portal.ParameterSetManager.
ParameterSetManager`
"""
parameterset = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema,
experiment__id=self.experiment_id)
if not len(parameterset):
if create:
experiment = Experiment.objects.get(id=self.experiment_id)
self.psm = ParameterSetManager(schema=self.schema,
parentObject=experiment)
else:
return None
else:
self.psm = ParameterSetManager(parameterset=parameterset[0])
return self.psm
def has_cc_license(self):
"""
:return: True if there's a cc license parameterset for the experiment
:rtype: boolean
"""
parameterset = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema,
experiment__id=self.experiment_id)
self.psm = None
if not len(parameterset):
return False
else:
return True
def save_license(self, request):
"""
Saves a license parameterset with the POST variables from the
creative commons form
:param request: a HTTP Request instance
:type request: :class:`django.http.HttpRequest`
"""
if request.POST['cc_js_want_cc_license'] == \
'sure':
cc_js_result_img = request.POST['cc_js_result_img']
cc_js_result_name = request.POST['cc_js_result_name']
cc_js_result_uri = request.POST['cc_js_result_uri']
self.psm.set_param("license_image", cc_js_result_img,
"License Image")
self.psm.set_param("license_name", cc_js_result_name,
"License Name")
self.psm.set_param("license_uri", cc_js_result_uri,
"License URI")
else:
self.psm.delete_params('license_image')
self.psm.delete_params('license_name')
self.psm.delete_params('license_uri')
parametersets = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema,
experiment__id=self.experiment_id)
for parameterset in parametersets:
parameterset.delete()
class CreativeCommonsHandler():
psm = None
schema = "http://www.tardis.edu.au/schemas" +\
"/creative_commons/2011/05/17"
experiment_id = None
def __init__(self, experiment_id=experiment_id, create=True):
"""
:param experiment_id: The id of the experiment
:type experiment_id: integer
:param create: If true, creates a new parameterset object to
hold the cc license
:type create: boolean
"""
self.experiment_id = experiment_id
if create:
self.psm = self.get_or_create_cc_parameterset(create=True)
else:
self.psm = self.get_or_create_cc_parameterset(create=False)
def get_or_create_cc_parameterset(self, create=True):
"""
Gets the creative commons parameterset for the experiment
:param create: If true, creates a new parameterset object to
hold the cc license if one doesn't exist
:type create: boolean
:return: The parameterset manager for the cc parameterset
:rtype: :class:`tardis.tardis_portal.ParameterSetManager.
ParameterSetManager`
"""
parameterset = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema, experiment__id=self.experiment_id)
if not len(parameterset):
if create:
experiment = Experiment.objects.get(id=self.experiment_id)
self.psm = ParameterSetManager(schema=self.schema,
parentObject=experiment)
else:
return None
else:
self.psm = ParameterSetManager(parameterset=parameterset[0])
return self.psm
def has_cc_license(self):
"""
:return: True if there's a cc license parameterset for the experiment
:rtype: boolean
"""
parameterset = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema, experiment__id=self.experiment_id)
self.psm = None
if not len(parameterset):
return False
else:
return True
def save_license(self, request):
"""
Saves a license parameterset with the POST variables from the
creative commons form
:param request: a HTTP Request instance
:type request: :class:`django.http.HttpRequest`
"""
if request.POST['cc_js_want_cc_license'] == \
'sure':
cc_js_result_img = request.POST['cc_js_result_img']
cc_js_result_name = request.POST['cc_js_result_name']
cc_js_result_uri = request.POST['cc_js_result_uri']
self.psm.set_param("license_image", cc_js_result_img,
"License Image")
self.psm.set_param("license_name", cc_js_result_name,
"License Name")
self.psm.set_param("license_uri", cc_js_result_uri, "License URI")
else:
self.psm.delete_params('license_image')
self.psm.delete_params('license_name')
self.psm.delete_params('license_uri')
parametersets = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema,
experiment__id=self.experiment_id)
for parameterset in parametersets:
parameterset.delete()
def save_dataset_metadata(self, datafile, schema, metadata):
psm = ParameterSetManager(parentObject=datafile.dataset,
schema=schema.namespace)
psm.set_param('admin-filename', datafile.filename)
self._save_metadata(psm, schema, metadata)
class CreativeCommonsHandler():
psm = None
schema = "http://www.tardis.edu.au/schemas" +\
"/creative_commons/2011/05/17"
experiment_id = None
def __init__(self, experiment_id=experiment_id, create=True):
self.experiment_id = experiment_id
if create:
self.psm = self.get_or_create_cc_parameterset(create=True)
else:
self.psm = self.get_or_create_cc_parameterset(create=False)
def get_or_create_cc_parameterset(self, create=True):
# get cc license parameterset, if any
parameterset = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema,
experiment__id=self.experiment_id)
if not len(parameterset):
if create:
experiment = Experiment.objects.get(id=self.experiment_id)
self.psm = ParameterSetManager(schema=self.schema,
parentObject=experiment)
else:
return None
else:
self.psm = ParameterSetManager(parameterset=parameterset[0])
return self.psm
def has_cc_license(self):
# get cc license parameterset, if any
parameterset = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema,
experiment__id=self.experiment_id)
self.psm = None
if not len(parameterset):
return False
else:
return True
def save_license(self, request):
# if cc license then save params
if request.POST['cc_js_want_cc_license'] ==\
'sure':
cc_js_result_img = request.POST['cc_js_result_img']
cc_js_result_name = request.POST['cc_js_result_name']
cc_js_result_uri = request.POST['cc_js_result_uri']
self.psm.set_param("license_image", cc_js_result_img,
"License Image")
self.psm.set_param("license_name", cc_js_result_name,
"License Name")
self.psm.set_param("license_uri", cc_js_result_uri,
"License URI")
else:
self.psm.delete_params('license_image')
self.psm.delete_params('license_name')
self.psm.delete_params('license_uri')
parametersets = ExperimentParameterSet.objects.filter(
schema__namespace=self.schema,
experiment__id=self.experiment_id)
for parameterset in parametersets:
parameterset.delete()
