Python ParameterSetManager.set_param方法代码示例

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
    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+\.$')

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
    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)

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
    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)

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
 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))

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
    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)

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
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

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]

#.........这里部分代码省略.........
                        )

        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

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
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()

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
 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)

# 需要导入模块: from tardis.tardis_portal.ParameterSetManager import ParameterSetManager [as 别名]
# 或者: from tardis.tardis_portal.ParameterSetManager.ParameterSetManager import set_param [as 别名]
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()