def add_data_product_version_to_collection(self, data_product_id='', data_product_collection_id='', version_name='', version_description=''):
dp_collection_obj =self.clients.resource_registry.read(data_product_collection_id)
#retrieve the stream definition for both the new data product to add to this collection and the base data product for this collection
new_data_product_obj = self.clients.resource_registry.read(data_product_id)
new_data_product_streams, _ = self.clients.resource_registry.find_objects(subject=data_product_id, predicate=PRED.hasStream, object_type=RT.Stream, id_only=True)
validate_is_not_none(new_data_product_streams, 'The data product to add to the collection must have an associated stream')
new_data_product_streamdefs, _ = self.clients.resource_registry.find_objects(subject=new_data_product_streams[0], predicate=PRED.hasStreamDefinition, object_type=RT.StreamDefinition, id_only=True)
base_data_product_id = dp_collection_obj.version_list[0].data_product_id
base_data_product_obj = self.clients.resource_registry.read(base_data_product_id)
base_data_product_streams, _ = self.clients.resource_registry.find_objects(subject=base_data_product_id, predicate=PRED.hasStream, object_type=RT.Stream, id_only=True)
validate_is_not_none(base_data_product_streams, 'The base data product in the collection must have an associated stream')
base_data_product_streamdefs, _ = self.clients.resource_registry.find_objects(subject=base_data_product_streams[0], predicate=PRED.hasStreamDefinition, object_type=RT.StreamDefinition, id_only=True)
if not self.clients.pubsub_management.compare_stream_definition(stream_definition1_id=new_data_product_streamdefs[0], stream_definition2_id=base_data_product_streamdefs[0]):
raise BadRequest("All Data Products in a collection must have equivelent stream definitions.")
#todo: validate that the spatial/temporal domain match the base data product
dpv = DataProductVersion()
dpv.name = version_name
dpv.description = version_description
dpv.data_product_id = data_product_id
dp_collection_obj.version_list.append(dpv)
self.clients.resource_registry.update(dp_collection_obj)
self.clients.resource_registry.create_association( subject=data_product_collection_id, predicate=PRED.hasVersion, object=data_product_id)
return
def create_data_product_collection(self, data_product_id='', collection_name='', collection_description=''):
"""Define a set of an existing data products that represent an improvement in the quality or
understanding of the information.
"""
validate_is_not_none(data_product_id, 'A data product identifier must be passed to create a data product version')
dpv = DataProductVersion()
dpv.name = 'base'
dpv.description = 'the base version on which subsequent versions are built'
dpv.data_product_id = data_product_id
dp_collection_obj = IonObject(RT.DataProductCollection, name=collection_name, description=collection_description, version_list=[dpv])
data_product_collection_id, rev = self.clients.resource_registry.create(dp_collection_obj)
self.clients.resource_registry.create_association( subject=data_product_collection_id, predicate=PRED.hasVersion, object=data_product_id)
return data_product_collection_id
def create_data_product(self, data_product=None, stream_definition_id='', parameter_dictionary = None):
"""
@param data_product IonObject which defines the general data product resource
@param source_resource_id IonObject id which defines the source for the data
@retval data_product_id
"""
# Create will validate and register a new data product within the system
validate_is_not_none(parameter_dictionary, 'A parameter dictionary must be passed to register a data product')
validate_is_not_none(stream_definition_id, 'A stream definition id must be passed to register a data product')
validate_is_not_none(data_product, 'A data product (ion object) must be passed to register a data product')
#--------------------------------------------------------------------------------
# Register - create and store a new DataProduct resource using provided metadata
#--------------------------------------------------------------------------------
data_product_id, rev = self.clients.resource_registry.create(data_product)
log.debug("data product id: %s" % data_product_id)
#--------------------------------------------------------------------------------
# Register - create and store the default DataProductVersion resource using provided metadata
#--------------------------------------------------------------------------------
#create the initial/default data product version
data_product_version = DataProductVersion()
data_product_version.name = data_product.name
data_product_version.description = data_product.description
dpv_id, rev = self.clients.resource_registry.create(data_product_version)
self.clients.resource_registry.create_association( subject=data_product_id, predicate=PRED.hasVersion, object=dpv_id)
#-----------------------------------------------------------------------------------------------
#Create the stream and a dataset if a stream definition is provided
#-----------------------------------------------------------------------------------------------
log.debug("DataProductManagementService:create_data_product: stream definition id = %s" % stream_definition_id)
#if stream_definition_id:
stream_id = self.clients.pubsub_management.create_stream(name=data_product.name,
description=data_product.description,
stream_definition_id=stream_definition_id)
# Associate the Stream with the main Data Product and with the default data product version
self.data_product.link_stream(data_product_id, stream_id)
self.clients.resource_registry.create_association( subject=dpv_id, predicate=PRED.hasStream, object=stream_id)
# create a dataset...
data_set_id = self.clients.dataset_management.create_dataset( name= 'data_set_%s' % stream_id,
stream_id=stream_id,
parameter_dict=parameter_dictionary,
temporal_domain=data_product.temporal_domain,
spatial_domain=data_product.spatial_domain)
log.debug("DataProductManagementService:create_data_product: data_set_id = %s" % str(data_set_id))
data_set_obj = self.clients.dataset_management.read_dataset(data_set_id)
log.debug("DataProductManagementService:create_data_product: data_set_obj = %s" % str(data_set_obj))
# link dataset with data product. This creates the association in the resource registry
self.data_product.link_data_set(data_product_id=data_product_id, data_set_id=data_set_id)
self.clients.resource_registry.create_association( subject=dpv_id, predicate=PRED.hasDataset, object=data_set_id)
# Return the id of the new data product
return data_product_id
