def convert_definition_to_v6_json(definition):
"""Returns the v6 dataset definition JSON for the given definition
:param definition: The dataset definition
:type definition: :class:`data.dataset.dataset.DataSetDefinition`
:returns: The v6 dataset definition JSON
:rtype: :class:`data.dataset.json.dataset_v6.DataSetDefinitionV6`
"""
def_dict = {
'version': SCHEMA_VERSION
}
if definition.parameters:
interface_dict = convert_interface_to_v6_json(definition.parameters).get_dict()
def_dict['parameters'] = rest_utils.strip_schema_version(interface_dict)
if definition.global_parameters:
interface_dict = convert_interface_to_v6_json(definition.global_parameters).get_dict()
def_dict['global_parameters'] = rest_utils.strip_schema_version(interface_dict)
if definition.global_data:
data_dict = convert_data_to_v6_json(definition.global_data).get_dict()
def_dict['global_data'] = rest_utils.strip_schema_version(data_dict)
return DataSetDefinitionV6(definition=def_dict, do_validate=False)
def get_v6_configuration_json(self):
"""Returns the batch configuration in v6 of the JSON schema
:returns: The batch configuration in v6 of the JSON schema
:rtype: dict
"""
return rest_utils.strip_schema_version(convert_configuration_to_v6(self.get_configuration()).get_dict())
def _post_v6(self, request):
"""The v6 version for validating a new batch
:param request: the HTTP POST request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
recipe_type_id = rest_util.parse_int(request, 'recipe_type_id')
definition_dict = rest_util.parse_dict(request, 'definition')
configuration_dict = rest_util.parse_dict(request,
'configuration',
required=False)
# Make sure the recipe type exists
try:
recipe_type = RecipeType.objects.get(pk=recipe_type_id)
except RecipeType.DoesNotExist:
raise BadParameter('Unknown recipe type: %d' % recipe_type_id)
try:
definition = BatchDefinitionV6(definition=definition_dict,
do_validate=True).get_definition()
configuration = BatchConfigurationV6(
configuration=configuration_dict,
do_validate=True).get_configuration()
except InvalidDefinition as ex:
raise BadParameter(unicode(ex))
except InvalidConfiguration as ex:
raise BadParameter(unicode(ex))
# Validate the batch
validation = Batch.objects.validate_batch_v6(
recipe_type, definition, configuration=configuration)
batch = validation.batch
recipe_type_serializer = RecipeTypeBaseSerializerV6(batch.recipe_type)
resp_dict = {
'is_valid': validation.is_valid,
'errors': [e.to_dict() for e in validation.errors],
'warnings': [w.to_dict() for w in validation.warnings],
'recipes_estimated': definition.estimated_recipes,
'recipe_type': recipe_type_serializer.data
}
if batch.superseded_batch:
recipe_type_rev_serializer = RecipeTypeRevisionBaseSerializerV6(
batch.superseded_batch.recipe_type_rev)
prev_batch_dict = {
'recipe_type_rev': recipe_type_rev_serializer.data
}
resp_dict['prev_batch'] = prev_batch_dict
if definition.prev_batch_diff:
diff_v6 = convert_recipe_diff_to_v6_json(
definition.prev_batch_diff)
diff_dict = rest_util.strip_schema_version(diff_v6.get_dict())
prev_batch_dict['diff'] = diff_dict
return Response(resp_dict)
def get_v6_data_json(self):
"""Returns the data for this datasetmember as v6 json with the version stripped
:returns: The v6 JSON output data dict for this datasetmember
:rtype: dict
"""
return rest_utils.strip_schema_version(
convert_data_to_v6_json(self.get_data()).get_dict())
def get_v6_definition_json(self):
"""Returns the dataset definition in v6 of the JSON schema
:returns: The dataset definition in v6 of the JSON schema
:rtype: dict
"""
return rest_utils.strip_schema_version(
convert_definition_to_v6_json(self.get_definition()).get_dict())
def get_v6_configuration_json(self):
"""Returns the scan configuration in v6 of the JSON schema
:returns: The scan configuration in v6 of the JSON schema
:rtype: dict
"""
#schemas are identical except for version number, just return dict with version stripped
return rest_utils.strip_schema_version(self.configuration)
def get_v6_definition_json(self):
"""Returns the batch definition in v6 of the JSON schema
:returns: The batch definition in v6 of the JSON schema
:rtype: dict
"""
# Handle batches with old (pre-v6) definitions
if 'version' in self.definition and self.definition['version'] == '1.0':
return {}
return rest_utils.strip_schema_version(convert_definition_to_v6(self.get_definition()).get_dict())
def _populate_default_values(self, do_validate=False):
"""Populates any missing JSON fields that have default values
"""
if 'parameters' not in self._definition:
self._definition['parameters'] = InterfaceV6().get_dict()
elif type(self._definition['parameters']) is not dict:
raise InvalidDataSetDefinition('INVALID_DATASET_DEFINITION', '"parameters" is not a dictionary')
else:
self._definition['parameters'] = InterfaceV6(interface=self._definition['parameters'], do_validate=do_validate).get_dict()
rest_utils.strip_schema_version(self._definition['parameters'])
if 'global_parameters' not in self._definition:
self._definition['global_parameters'] = InterfaceV6().get_dict()
elif type(self._definition['global_parameters']) is not dict:
raise InvalidDataSetDefinition('INVALID_DATASET_DEFINITION', '"global_parameters" is not a dictionary')
else:
self._definition['global_parameters'] = InterfaceV6(interface=self._definition['global_parameters'], do_validate=do_validate).get_dict()
rest_utils.strip_schema_version(self._definition['global_parameters'])
if 'global_data' not in self._definition:
self._definition['global_data'] = DataV6().get_dict()
elif type(self._definition['global_data']) is not dict:
raise InvalidDataSetDefinition('INVALID_DATASET_DEFINITION', '"global_data" is not a dictionary')
else:
self._definition['global_data'] = DataV6(data=self._definition['global_data'], do_validate=do_validate).get_dict()
rest_utils.strip_schema_version(self._definition['global_data'])
def _populate_default_values(self):
"""Populates any missing required values with defaults
"""
if 'input' not in self._definition:
self._definition['input'] = {}
if 'nodes' not in self._definition:
self._definition['nodes'] = {}
# Populate defaults for input interface
interface_json = InterfaceV6(self._definition['input'],
do_validate=False)
self._definition['input'] = strip_schema_version(
interface_json.get_dict())
