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()