def to_data(instance: CdmAttributeResolutionGuidanceDefinition, res_opt: ResolveOptions, options: CopyOptions) -> Optional[AttributeResolutionGuidance]: if not instance: return None result = AttributeResolutionGuidance() result.removeAttribute = instance.remove_attribute result.imposedDirectives = instance.imposed_directives result.removedDirectives = instance.removed_directives result.cardinality = instance.cardinality result.renameFormat = instance.rename_format if instance.add_supporting_attribute: result.addSupportingAttribute = PersistenceLayer.to_data( instance.add_supporting_attribute, res_opt, 'CdmFolder', options) if instance.expansion: result.expansion = Expansion() result.expansion.startingOrdinal = instance.expansion.starting_ordinal result.expansion.maximumExpansion = instance.expansion.maximum_expansion if instance.expansion.count_attribute: result.expansion.countAttribute = PersistenceLayer.to_data( instance.expansion.count_attribute, res_opt, 'CdmFolder', options) if instance.entity_by_reference: result.entityByReference = EntityByReference() result.entityByReference.allowReference = instance.entity_by_reference.allow_reference result.entityByReference.alwaysIncludeForeignKey = instance.entity_by_reference.always_include_foreign_key result.entityByReference.referenceOnlyAfterDepth = instance.entity_by_reference.reference_only_after_depth if instance.entity_by_reference.foreign_key_attribute: result.entityByReference.foreignKeyAttribute = PersistenceLayer.to_data( instance.entity_by_reference.foreign_key_attribute, res_opt, 'CdmFolder', options) if instance.selects_sub_attribute: result.selectsSubAttribute = SelectsSubAttribute() result.selectsSubAttribute.selects = instance.selects_sub_attribute.selects if instance.selects_sub_attribute.selected_type_attribute: result.selectsSubAttribute.selectedTypeAttribute = PersistenceLayer.to_data( instance.selects_sub_attribute.selected_type_attribute, res_opt, 'CdmFolder', options) result.selectsSubAttribute.selectsSomeTakeNames = instance.selects_sub_attribute.selects_some_take_names result.selectsSubAttribute.selectsSomeAvoidNames = instance.selects_sub_attribute.selects_some_avoid_names return result
async def test_cdm_folder_to_data_type_attribute(self): """ Testing that "is.localized.describedAs" trait with a table of three entries (en, rs and cn) is fully preserved when running CdmFolder TypeAttributePersistence ToData. """ corpus = CdmCorpusDefinition() corpus.ctx.report_at_level = CdmStatusLevel.WARNING corpus.storage.mount('local', LocalAdapter('C:\\Root\\Path')) corpus.storage.default_namespace = 'local' cdm_type_attribute_definition = corpus.make_object(CdmObjectType.TYPE_ATTRIBUTE_DEF, 'TestSavingTraitAttribute', False) english_constants_list = ['en', 'Some description in English language'] serbian_constants_list = ['sr', 'Opis na srpskom jeziku'] chinese_constants_list = ['cn', '一些中文描述'] list_of_const_lists = [english_constants_list, serbian_constants_list, chinese_constants_list] const_ent_def = corpus.make_object(CdmObjectType.CONSTANT_ENTITY_DEF, 'localizedDescriptions', False) const_ent_def.constant_values = list_of_const_lists const_ent_def.entity_shape = corpus.make_ref(CdmObjectType.ENTITY_REF, 'localizedTable', True) trait_reference2 = corpus.make_object(CdmObjectType.TRAIT_REF, 'is.localized.describedAs', False) trait_reference2.arguments.append('localizedDisplayText', corpus.make_ref(CdmObjectType.ENTITY_REF, const_ent_def, True)) cdm_type_attribute_definition.applied_traits.append(trait_reference2) result = TypeAttribute().decode(PersistenceLayer.to_data(cdm_type_attribute_definition, None, None, PersistenceLayer.CDM_FOLDER)) self.assertIsNotNone(result.appliedTraits) argument = result.appliedTraits[0].arguments[0] constant_values = argument.value.entityReference.constantValues self.assertEqual('en', constant_values[0][0]) self.assertEqual('Some description in English language', constant_values[0][1]) self.assertEqual('sr', constant_values[1][0]) self.assertEqual('Opis na srpskom jeziku', constant_values[1][1]) self.assertEqual('cn', constant_values[2][0]) self.assertEqual('一些中文描述', constant_values[2][1])
def to_data(instance: CdmAttributeContext, res_opt: ResolveOptions, options: CopyOptions) -> AttributeContext: result = AttributeContext() exhibits_traits = [ trait for trait in instance.exhibits_traits if not trait.is_from_property ] result.explanation = instance.explanation result.name = instance.name result.type = map_enum_to_type_name[instance.type] result.parent = AttributeContextReferencePersistence.to_data( instance.parent, res_opt, options) if instance.parent is not None else None result.definition = PersistenceLayer.to_data( instance.definition, res_opt, options, PersistenceLayer.CDM_FOLDER ) if instance.definition is not None else None # I know the trait collection names look wrong. but I wanted to use the def baseclass result.appliedTraits = copy_data_utils._array_copy_data( res_opt, exhibits_traits, options) result.contents = copy_data_utils._array_copy_data( res_opt, instance.contents, options) return result
def to_data(instance: CdmObjectReference, res_opt: ResolveOptions, options: CopyOptions) -> CdmJsonType: # We don't know what object we are creating to initialize to any copy = None replace = None if instance.named_reference: identifier = utils.copy_identifier_ref(instance, res_opt, options) if instance.simple_named_reference: return identifier replace = CdmObjectRefPersistence._copy_ref_data(instance, res_opt, copy, identifier, options) if replace: copy = replace elif instance.explicit_reference: er_copy = PersistenceLayer.to_data(instance.explicit_reference, res_opt, options, PersistenceLayer.CDM_FOLDER) replace = CdmObjectRefPersistence._copy_ref_data(instance, res_opt, copy, er_copy, options) if replace: copy = replace if instance.optional is not None: copy.optional = instance.optional if instance.applied_traits: # We don't know if the object we are copying has applied traits or not and hence use any copy.appliedTraits = copy_data_utils._array_copy_data(res_opt, instance.applied_traits, options) return copy
async def test_from_and_to_data_with_elevated_traits(self): corpus = TestHelper.get_local_corpus( self.tests_subpath, 'test_from_and_to_data_with_elevated_traits') # need to set schema docs to the cdm namespace instead of using resources corpus.storage.mount("cdm", LocalAdapter(TestHelper.get_schema_docs_root())) def callback(level, message): self.assertTrue('unable to resolve an entity' not in message) corpus.set_event_callback(callback, CdmStatusLevel.WARNING) entity = await corpus.fetch_object_async( 'local:/Account.cdm.json/Account') # type: CdmEntityDefinition res_entity = await entity.create_resolved_entity_async( '{}_'.format(entity.entity_name)) # type: CdmEntityDefinition PersistenceLayer.to_data( res_entity, ResolveOptions(wrt_doc=res_entity.in_document), CopyOptions(string_refs=True), PersistenceLayer.CDM_FOLDER)
def fetch_value_string(self, res_opt: 'ResolveOptions') -> str: from cdm.objectmodel import CdmObject if self.value is None: return '' if isinstance(self.value, str): return self.value elif isinstance(self.value, CdmObject): # If this is a constant table, then expand into an HTML table. object_def = self.value.fetch_object_definition( res_opt) # type: CdmConstantEntityDefinition if self.value.object_type == CdmObjectType.ENTITY_REF and object_def is not None and object_def.object_type == CdmObjectType.CONSTANT_ENTITY_DEF: ent_shape = object_def.entity_shape ent_values = object_def.constant_values if not ent_values: return '' rows = [] shape_atts = ent_shape._fetch_resolved_attributes(res_opt) if shape_atts is not None and shape_atts._set is not None: for row_data in ent_values: if not row_data: continue row = OrderedDict() for (c, tvalue) in enumerate(row_data): col_att = shape_atts._set[c] if col_att is not None and tvalue is not None: row[col_att.resolved_name] = tvalue rows.append(row) rows_string = [self._spew_dict(row) for row in rows] return '[' + ','.join(rows_string) + ']' # Should be a reference to an object. from cdm.persistence import PersistenceLayer from cdm.utilities import CopyOptions data = PersistenceLayer.to_data(self.value, res_opt, CopyOptions(string_refs=False), PersistenceLayer.CDM_FOLDER) if isinstance(data, str): return data # TODO: the line bellow won't work, the result is going to be the address of the object. return str(data) else: return str(self.value) return ''
def to_data(instance: CdmParameterDefinition, res_opt: ResolveOptions, options: CopyOptions) -> Parameter: def_val = None if instance.default_value: if isinstance(instance.default_value, CdmObject): def_val = PersistenceLayer.to_data(instance.default_value, res_opt, options, PersistenceLayer.CDM_FOLDER) elif isinstance(instance.default_value, str): def_val = instance.default_value result = Parameter() result.name = instance.name result.dataType = PersistenceLayer.to_data( instance.data_type_ref, res_opt, options, PersistenceLayer.CDM_FOLDER) if instance.data_type_ref else None result.explanation = instance.explanation result.defaultValue = def_val result.required = instance.required return result
def array_copy_data(res_opt: ResolveOptions, source: Union['CdmCollection', List['CdmObject']], options: CopyOptions) -> Optional[List]: """Creates a list object that is a copy of the input IEnumerable object""" if not source: return None casted = [] for elem in source: if elem: data = PersistenceLayer.to_data(elem, res_opt, 'CdmFolder', options) casted.append(data) return casted
def _array_copy_data(res_opt: 'ResolveOptions', source: Union['CdmCollection', List['CdmObject']], options: 'CopyOptions') -> Optional[List]: """Creates a list object that is a copy of the input IEnumerable object""" if not source: return None casted = [] for elem in source: if elem: from cdm.persistence import PersistenceLayer data = PersistenceLayer.to_data(elem, res_opt, options, PersistenceLayer.CDM_FOLDER) casted.append(data) return casted
def test_non_null_default_value_attribute(self): the_list = [{ 'languageTag': 'en', 'displayText': 'Preferred Customer', 'attributeValue': '1', 'displayOrder': '0' }, { 'languageTag': 'en', 'displayText': 'Standard', 'attributeValue': '2', 'displayOrder': '1' }] input = {'defaultValue': the_list} cdmTypeAttributeDefinition = PersistenceLayer.from_data(CdmCorpusContext(CdmCorpusDefinition(), None), JObject(input), CdmObjectType.TYPE_ATTRIBUTE_DEF, PersistenceLayer.CDM_FOLDER) result = PersistenceLayer.to_data(cdmTypeAttributeDefinition, None, None, PersistenceLayer.CDM_FOLDER) self.assertTrue(result) self.assertEqual(result.get('defaultValue'), input.get('defaultValue'))
def to_data(instance: 'CdmArgumentDefinition', res_opt: 'ResolveOptions', options: 'CopyOptions') -> CdmJsonType: from cdm.objectmodel import CdmObject value = None if instance.value is not None: if isinstance(instance.value, CdmObject): value = PersistenceLayer.to_data(instance.value, res_opt, options, PersistenceLayer.CDM_FOLDER) else: value = instance.value # Skip the argument if just a value if not instance.name: return value arg = Argument() arg.explanation = instance.explanation arg.name = instance.name arg.value = value return arg
async def test_save_projection(self): """Basic test to save persisted Projections based entities""" corpus = TestHelper.get_local_corpus(self.tests_subpath, 'test_save_projection') # type CdmCorpusDefinition manifest = await corpus.fetch_object_async('local:/default.manifest.cdm.json') # type CdmManifestDefinition entity_sales = await corpus.fetch_object_async('local:/Sales.cdm.json/Sales', manifest) # type CdmEntityDefinition self.assertIsNotNone(entity_sales) actual_root = corpus.storage.fetch_root_folder("output") # type CdmFolderDefinition self.assertIsNotNone(actual_root) actual_root._documents.append(entity_sales.in_document, 'Persisted_Sales.cdm.json') await actual_root._documents.__getitem__(0).save_as_async('output:/Persisted_Sales.cdm.json') entity_actual = await corpus.fetch_object_async('output:/Persisted_Sales.cdm.json/Sales', manifest) # type CdmEntityDefinition self.assertIsNotNone(entity_actual) entity_content_actual = PersistenceLayer.to_data(entity_actual, None, None, 'CdmFolder') # type Entity self.assertIsNotNone(entity_content_actual) self.assertIsNotNone(entity_content_actual.hasAttributes) self.assertTrue(len(entity_content_actual.hasAttributes) == 1) self.assertFalse('"entityReference"' in str(entity_content_actual.hasAttributes[0]))