async def to_data(instance: 'CdmReferencedEntityDeclarationDefinition',
res_opt: 'ResolveOptions',
options: 'CopyOptions') -> Optional['ReferenceEntity']:
source_index = instance.entity_path.rfind('/')
if source_index == -1:
instance.ctx.logger.error(
'Source name is not present in entityDeclaration path. | %s',
instance.at_corpus_path)
return
reference_entity = ReferenceEntity()
t2pm = TraitToPropertyMap(instance)
reference_entity.type = 'ReferenceEntity'
reference_entity.name = instance.entity_name
reference_entity.source = instance.entity_path[source_index + 1:]
reference_entity.description = instance.explanation
reference_entity.lastFileStatusCheckTime = utils.get_formatted_date_string(
instance.last_file_status_check_time)
reference_entity.lastFileModifiedTime = utils.get_formatted_date_string(
instance.last_file_modified_time)
reference_entity.isHidden = bool(
t2pm.fetch_trait_reference('is.hidden')) or None
properties_trait = t2pm.fetch_trait_reference(
'is.propertyContent.multiTrait')
if properties_trait:
reference_entity.modelId = properties_trait.arguments[0].value
await utils.process_annotations_to_data(instance.ctx, reference_entity,
instance.exhibits_traits)
return reference_entity
async def to_data(instance: 'CdmDataPartitionDefinition', res_opt: 'ResolveOptions', options: 'CopyOptions') -> Optional['Partition']:
result = Partition()
result.name = instance.name
result.description = instance.description
result.location = instance.ctx.corpus.storage.corpus_path_to_adapter_path(
instance.ctx.corpus.storage.create_absolute_corpus_path(instance.location, instance.in_document))
result.refreshTime = instance.refresh_time
result.lastFileModifiedTime = utils.get_formatted_date_string(instance.last_file_modified_time)
result.lastFileStatusCheckTime = utils.get_formatted_date_string(instance.last_file_status_check_time)
if not result.location:
logger.warning(DataPartitionPersistence.__name__, instance.ctx,
'Couldn\'t find data partition\'s location for partition {}.'.format(result.name), DataPartitionPersistence.to_data.__name__)
# filter description since it is mapped to a property
exhibits_traits = filter(lambda t: t.named_reference != 'is.localized.describedAs', instance.exhibits_traits)
await utils.process_annotations_to_data(instance.ctx, result, exhibits_traits)
t2pm = TraitToPropertyMap(instance)
is_hidden_trait = t2pm.fetch_trait_reference('is.hidden')
result.isHidden = bool(is_hidden_trait) or None
csv_trait = t2pm.fetch_trait_reference('is.partition.format.CSV')
if csv_trait:
csv_format_settings = utils.create_csv_format_settings(csv_trait)
if csv_format_settings:
result.fileFormatSettings = csv_format_settings
result.fileFormatSettings.type = 'CsvFormatSettings'
else:
logger.error(DataPartitionPersistence.__name__, instance.ctx, 'There was a problem while processing csv format trait inside data partition.')
return
return result
async def to_data(instance: 'CdmLocalEntityDeclarationDefinition', res_opt: 'ResolveOptions', options: 'CopyOptions',
ctx: 'CdmCorpusContext') -> 'LocalEntity':
# Fetch the document from entity schema.
entity = await DocumentPersistence.to_data(instance.entity_path, res_opt, options, ctx)
if not entity:
return None
entity.description = instance.explanation
entity.lastFileStatusCheckTime = utils.get_formatted_date_string(instance.last_file_status_check_time)
entity.lastFileModifiedTime = utils.get_formatted_date_string(instance.last_file_modified_time)
entity.lastChildFileModifiedTime = utils.get_formatted_date_string(instance.last_child_file_modified_time)
t2pm = TraitToPropertyMap(instance)
# Find the trait containing the schema info.
schemas = t2pm.fetch_property_value('cdmSchemas')
if schemas:
entity.schemas = schemas
entity.isHidden = bool(t2pm.fetch_trait_reference('is.hidden')) or None
if instance.data_partitions:
entity.partitions = []
for partition in instance.data_partitions:
partiton = await DataPartitionPersistence.to_data(partition, res_opt, options, ctx)
if partition:
entity.partitions.append(partiton)
else:
ctx.logger.error('There was an error while trying to convert cdm data partition to model.json partition.')
return None
return entity
async def to_data(instance: 'CdmTypeAttributeDefinition',
res_opt: 'ResolveOptions',
options: 'CopyOptions') -> 'Attribute':
result = Attribute()
result.name = instance.name
result.description = instance.description
result.dataType = TypeAttributePersistence.data_type_to_data[
instance.data_format]
await utils.process_annotations_to_data(instance.ctx, result,
instance.applied_traits)
t2pm = TraitToPropertyMap(instance)
result.isHidden = bool(t2pm.fetch_trait_reference('is.hidden')) or None
return result
async def to_data(instance: 'CdmManifestDefinition',
res_opt: 'ResolveOptions',
options: 'CopyOptions') -> Optional['Model']:
result = Model()
# process_annotations_to_data also processes extensions.
await utils.process_annotations_to_data(instance.ctx, result,
instance.exhibits_traits)
result.name = instance.manifest_name
result.description = instance.explanation
result.modifiedTime = utils.get_formatted_date_string(
instance.last_file_modified_time)
result.lastChildFileModifiedTime = utils.get_formatted_date_string(
instance.last_child_file_modified_time)
result.lastFileStatusCheckTime = utils.get_formatted_date_string(
instance.last_file_status_check_time)
t2pm = TraitToPropertyMap(instance)
result.isHidden = bool(t2pm.fetch_trait_reference('is.hidden')) or None
application_trait = t2pm.fetch_trait_reference('is.managedBy')
if application_trait:
result.application = application_trait.arguments[0].value
version_trait = t2pm.fetch_trait_reference('means.measurement.version')
if version_trait:
result.version = version_trait.arguments[0].value
else:
result.version = '1.0'
culture_trait = t2pm.fetch_trait_reference('is.partition.culture')
if culture_trait:
result.culture = culture_trait.arguments[0].value
reference_entity_locations = {}
reference_models = {}
reference_models_trait = t2pm.fetch_trait_reference(
'is.modelConversion.referenceModelMap')
if reference_models_trait:
ref_models = reference_models_trait.arguments[0].value
for element in ref_models:
reference_models[element.id] = element.location
reference_entity_locations[element.location] = element.id
if instance.entities:
result.entities = []
# Schedule processing of each entity to be added to the manifest
for entity in instance.entities:
element = None
if entity.object_type == CdmObjectType.LOCAL_ENTITY_DECLARATION_DEF:
element = await LocalEntityDeclarationPersistence.to_data(
entity, res_opt, options, instance.ctx)
elif entity.object_type == CdmObjectType.REFERENCED_ENTITY_DECLARATION_DEF:
element = await ReferencedEntityDeclarationPersistence.to_data(
entity, res_opt, options)
reference_entity = element
location = instance.ctx.corpus.storage.corpus_path_to_adapter_path(
entity.entity_path)
entity_index = location.rfind('/')
location = location[:entity_index]
if reference_entity.modelId:
if reference_entity.modelId not in reference_models:
reference_models[
reference_entity.modelId] = location
reference_entity_locations[
location] = reference_entity.modelId
elif location in reference_entity_locations:
reference_entity.modelId = reference_entity_locations[
location]
else:
reference_entity.modelId = str(uuid.uuid4())
reference_models[reference_entity.modelId] = location
reference_entity_locations[
location] = reference_entity.modelId
if element:
result.entities.append(element)
else:
instance.ctx.logger.error(
'There was an error while trying to convert entity declaration to model json format.'
)
if reference_models:
for value, key in reference_models.items():
model = ReferenceModel()
model.id = value
model.location = key
result.referenceModels.append(model)
for cdm_relationship in instance.relationships:
relationship = await RelationshipPersistence.to_data(
cdm_relationship, res_opt, options, instance.ctx)
if relationship:
result.relationships.append(relationship)
else:
instance.ctx.logger.error(
'There was an error while trying to convert cdm relationship to model.json relationship.'
)
return None
if instance.imports:
result.imports = []
for element in instance.imports:
import_obj = ImportPersistence.to_data(element, res_opt,
options)
if import_obj:
result.imports.append(import_obj)
return result
