static void PrintTrait(CdmTraitReference trait) { if (!string.IsNullOrEmpty(trait.FetchObjectDefinitionName())) { Console.WriteLine(" " + trait.FetchObjectDefinitionName()); foreach (var argDef in trait.Arguments) { if (argDef.Value is CdmEntityReference) { Console.WriteLine(" Constant: ["); var contEntDef = argDef.Value.FetchObjectDefinition <CdmConstantEntityDefinition>(); foreach (List <string> constantValueList in contEntDef.ConstantValues) { Console.WriteLine($" [{String.Join(", ", constantValueList.ToArray())}]"); } Console.WriteLine(" ]"); } else { // Default output, nothing fancy for now Console.WriteLine(" " + argDef.Value); } } } }
/// <summary> /// Used as helper for converting a Manifest to a Model. /// Adds an extension stored in "Manifest" format to the data structure representing a <see cref="Model"/> /// </summary> /// <param name="extensionTraitRef"> /// The data structure containing the extension in the format used by the Manifest /// </param> /// <param name="destination"> /// The data structure used by <see cref="Model"/> where the data will be added to. /// There are multiple data structures that can have extensions, and any of these can be used here (assuming they are used by Model.Json data format) /// </param> public static void ProcessExtensionTraitToObject(CdmTraitReference extensionTraitRef, MetadataObject destination) { if (destination.ExtensionFields == null) { destination.ExtensionFields = new JObject(); } string originalExtensionName = RemoveExtensionTraitNamePrefix(extensionTraitRef.NamedReference); JToken extensionValue; if (extensionTraitRef.Arguments.Count == 1 && extensionTraitRef.Arguments[0].Name == extensionTraitRef.NamedReference) { extensionValue = extensionTraitRef.Arguments[0].Value; } else { var extensionValueAsJObject = new JObject(); foreach (CdmArgumentDefinition argument in extensionTraitRef.Arguments) { var propertyName = argument.Name; var propertyValue = argument.Value; extensionValueAsJObject.Add(propertyName, propertyValue); } extensionValue = extensionValueAsJObject; } destination.ExtensionFields.Add(originalExtensionName, extensionValue); }
public async Task TestAlterArguments() { string testName = nameof(TestAlterArguments); string entityName = "NewPerson"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); corpus.Storage.Mount("traitGroup", new LocalAdapter(traitGroupFilePath)); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); // Create resolution options with the 'referenceOnly' directive. CdmEntityDefinition resolvedEntityWithReferenceOnly = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "referenceOnly" }); // Original set of attributes: ["name", "age", "address[means.TraitG4(scale:15)]" , "phoneNumber", "email"] // Condition not met, no trait is changed Assert.AreEqual("address", ((CdmTypeAttributeDefinition)resolvedEntityWithReferenceOnly.Attributes[2]).Name); CdmTraitReference traitG4 = (CdmTraitReference)resolvedEntityWithReferenceOnly.Attributes[2].AppliedTraits.Item("means.TraitG4"); Assert.IsNotNull(traitG4); Assert.IsNull(traitG4.Arguments.FetchValue("precision")); Assert.AreEqual("15", traitG4.Arguments.FetchValue("scale")); // Create resolution options with the 'structured' directive. CdmEntityDefinition resolvedEntityWithStructured = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "structured" }); // Original set of attributes: ["name", "age", "address[means.TraitG4(scale:15)]" , "phoneNumber", "email"] // Condition met, alter traits on ["address", + { "means.TraitG4, "arguments": ["6", {"name": "scale","value": "20"}"] }] Assert.AreEqual("address", ((CdmTypeAttributeDefinition)resolvedEntityWithStructured.Attributes[2]).Name); CdmTraitReference traitG4_1 = (CdmTraitReference)resolvedEntityWithStructured.Attributes[2].AppliedTraits.Item("means.TraitG4"); Assert.IsNotNull(traitG4_1); Assert.AreEqual("6", traitG4_1.Arguments.FetchValue("precision")); Assert.AreEqual("20", traitG4_1.Arguments.FetchValue("scale")); // Create resolution options with the 'normalized' directive. CdmEntityDefinition resolvedEntityWithNormalized = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { "normalized" }); // Original set of attributes: ["name", "age", "address[means.TraitG4(scale:15)]" , "phoneNumber", "email"] // Condition met, alter traits on ["address", + { "means.TraitG4, "arguments": ["8", null] }] Assert.AreEqual("address", ((CdmTypeAttributeDefinition)resolvedEntityWithNormalized.Attributes[2]).Name); CdmTraitReference traitG4_2 = (CdmTraitReference)resolvedEntityWithNormalized.Attributes[2].AppliedTraits.Item("means.TraitG4"); Assert.IsNotNull(traitG4_2); Assert.AreEqual("8", traitG4_2.Arguments.FetchValue("precision")); Assert.AreEqual("", traitG4_2.Arguments.FetchValue("scale")); }
public async Task TestAlterTraitsOnAttrGrpProj() { string testName = nameof(TestAlterTraitsOnAttrGrpProj); string entityName = "NewPerson"; CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName); corpus.Storage.Mount("traitGroup", new LocalAdapter(traitGroupFilePath)); foreach (List <string> resOpt in resOptsCombinations) { await ProjectionTestUtils.LoadEntityForResolutionOptionAndSave(corpus, testName, testsSubpath, entityName, resOpt); } CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>($"local:/{entityName}.cdm.json/{entityName}"); CdmEntityDefinition resolvedEntity = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> { }); CdmAttributeGroupReference attGroupReference = resolvedEntity.Attributes[0] as CdmAttributeGroupReference; CdmAttributeGroupDefinition attGroupDefinition = attGroupReference.ExplicitReference as CdmAttributeGroupDefinition; Assert.AreEqual(5, attGroupDefinition.Members.Count); Assert.AreEqual("PersonAttributeGroup", attGroupDefinition.AttributeGroupName); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("means.TraitG100")); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("means.TraitG200")); Assert.IsNull(attGroupDefinition.ExhibitsTraits.Item("means.TraitG300")); Assert.IsNotNull(attGroupDefinition.ExhibitsTraits.Item("means.TraitG400")); CdmTraitReference traitG4 = (CdmTraitReference)attGroupDefinition.ExhibitsTraits.Item("means.TraitG4"); Assert.IsNotNull(traitG4); Assert.AreEqual("5", traitG4.Arguments.FetchValue("precision")); Assert.AreEqual("15", traitG4.Arguments.FetchValue("scale")); }
public void CdmTraitCollectionRemoveOnlyFromProperty() { var manifest = CdmCollectionHelperFunctions.GenerateManifest(); var trait = new CdmTraitReference(manifest.Ctx, "TraitName", false, false); var otherTrait = new CdmTraitReference(manifest.Ctx, "Name of other Trait", false, false); manifest.ExhibitsTraits.Add(trait); manifest.ExhibitsTraits.Add(otherTrait); Assert.IsFalse(trait.IsFromProperty); Assert.IsFalse(otherTrait.IsFromProperty); Assert.AreEqual(2, manifest.ExhibitsTraits.Count); var removed = manifest.ExhibitsTraits.Remove(trait, true); Assert.IsFalse(removed); Assert.AreEqual(2, manifest.ExhibitsTraits.Count); otherTrait.IsFromProperty = true; removed = manifest.ExhibitsTraits.Remove(otherTrait, true); Assert.IsTrue(removed); Assert.AreEqual(1, manifest.ExhibitsTraits.Count); Assert.AreEqual(trait, manifest.ExhibitsTraits[0]); }
internal static CsvFormatSettings CreateCsvFormatSettings(CdmTraitReference cdmTraitRef) { var result = new CsvFormatSettings(); foreach (var argument in cdmTraitRef.Arguments) { switch (argument.Name) { case "columnHeaders": result.ColumnHeaders = argument.Value == "true"; break; case "csvStyle": result.CsvStyle = argument.Value; break; case "delimiter": result.Delimiter = argument.Value; break; case "quoteStyle": result.QuoteStyle = argument.Value; break; case "encoding": result.Encoding = argument.Value; break; } } return(result); }
internal void UpdateTraitTable(string traitName, string argName, string entityName, Action <CdmConstantEntityDefinition, bool> action) { CdmTraitReference trait = this.FetchOrCreateTrait(traitName, false); if (trait.Arguments == null || trait.Arguments.Count == 0) { // make the argument nothing but a ref to a constant entity, safe since there is only one param for the trait and it looks cleaner var cEnt = this.Ctx.Corpus.MakeObject <CdmConstantEntityDefinition>(CdmObjectType.ConstantEntityDef, null, false); cEnt.EntityShape = this.Ctx.Corpus.MakeRef <CdmEntityReference>(CdmObjectType.EntityRef, entityName, true) as CdmEntityReference; action(cEnt, true); trait.Arguments.Add(argName, this.Ctx.Corpus.MakeRef <CdmEntityReference>(CdmObjectType.EntityRef, cEnt, false)); } else { var locEntRef = FetchTraitReferenceArgumentValue(trait as CdmTraitReference, argName); if (locEntRef != null) { var locEnt = locEntRef.FetchObjectDefinition <CdmConstantEntityDefinition>(null); if (locEnt != null) { action(locEnt, false); } } } }
/// <summary> /// Create a relationship linking by creating an eneity attribute definition instance with a trait. /// This allows you to add a resolution guidance to customize your data. /// </summary> /// <param name="cdmCorpus"> The CDM corpus. </param> /// <param name="associatedEntityName"> The name of the associated entity. </param> /// <param name="foreignKeyName"> The name of the foreign key. </param> /// <param name="attributeExplanation"> The explanation of the attribute.</param> /// <returns> The instatnce of entity attribute definition. </returns> private static CdmEntityAttributeDefinition CreateAttributeForRelationshipBetweenTwoEntities( CdmCorpusDefinition cdmCorpus, string associatedEntityName, string foreignKeyName, string attributeExplanation) { // Define a relationship by creating an entity attribute var entityAttributeDef = cdmCorpus.MakeObject <CdmEntityAttributeDefinition>(CdmObjectType.EntityAttributeDef, foreignKeyName); entityAttributeDef.Explanation = attributeExplanation; // Creating an entity reference for the associated entity CdmEntityReference associatedEntityRef = cdmCorpus.MakeRef <CdmEntityReference>(CdmObjectType.EntityRef, associatedEntityName, false); // Creating a "is.identifiedBy" trait for entity reference CdmTraitReference traitReference = cdmCorpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "is.identifiedBy", false); traitReference.Arguments.Add(null, $"{associatedEntityName}/(resolvedAttributes)/{associatedEntityName}Id"); // Add the trait to the attribute's entity reference associatedEntityRef.AppliedTraits.Add(traitReference); entityAttributeDef.Entity = associatedEntityRef; // Add resolution guidance var attributeResolution = cdmCorpus.MakeObject <CdmAttributeResolutionGuidance>(CdmObjectType.AttributeResolutionGuidanceDef); attributeResolution.entityByReference = attributeResolution.makeEntityByReference(); attributeResolution.entityByReference.allowReference = true; attributeResolution.renameFormat = "{m}"; var entityAttribute = CreateEntityAttributeWithPurposeAndDataType(cdmCorpus, $"{foreignKeyName}Id", "identifiedBy", "entityId"); attributeResolution.entityByReference.foreignKeyAttribute = entityAttribute as CdmTypeAttributeDefinition; entityAttributeDef.ResolutionGuidance = attributeResolution; return(entityAttributeDef); }
/// <summary> /// Validates trait for this test class. /// </summary> /// <param name="attribute">The type attribute.</param> /// <param name="expectedAttrName">The expected attribute name.</param> /// <param name="haveTraitG4">Whether this attribute has "means.TraitG4".</param> /// <param name="doesNotExist">Whether this attribute has traits from <c traitGroupFilePath/>.</param> /// <returns></returns> private static void ValidateTrait(CdmTypeAttributeDefinition attribute, string expectedAttrName, bool haveTraitG4 = false, bool doesNotExist = false) { Assert.AreEqual(expectedAttrName, attribute.Name); if (!doesNotExist) { Assert.IsNotNull(attribute.AppliedTraits.Item("means.TraitG100")); Assert.IsNotNull(attribute.AppliedTraits.Item("means.TraitG200")); Assert.IsNull(attribute.AppliedTraits.Item("means.TraitG300")); Assert.IsNotNull(attribute.AppliedTraits.Item("means.TraitG400")); if (haveTraitG4) { CdmTraitReference traitG4 = (CdmTraitReference)attribute.AppliedTraits.Item("means.TraitG4"); Assert.IsNotNull(traitG4); Assert.AreEqual("5", traitG4.Arguments.FetchValue("precision")); Assert.AreEqual("15", traitG4.Arguments.FetchValue("scale")); } } else { Assert.IsNull(attribute.AppliedTraits.Item("means.TraitG100")); Assert.IsNull(attribute.AppliedTraits.Item("means.TraitG200")); Assert.IsNull(attribute.AppliedTraits.Item("means.TraitG300")); Assert.IsNull(attribute.AppliedTraits.Item("means.TraitG400")); Assert.IsNull(attribute.AppliedTraits.Item("means.TraitG4")); } }
public void CdmTraitCollectionRemovePrioritizeFromProperty() { var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path"); var trait = new CdmTraitReference(manifest.Ctx, "TraitName", false, false); var otherTrait = new CdmTraitReference(manifest.Ctx, "Name of other Trait", false, false); manifest.ExhibitsTraits.Add(trait); manifest.ExhibitsTraits.Add(otherTrait); var traitCopyFromProperty = new CdmTraitReference(manifest.Ctx, "TraitName", false, false); traitCopyFromProperty.IsFromProperty = true; manifest.ExhibitsTraits.Add(traitCopyFromProperty); Assert.IsFalse(trait.IsFromProperty); Assert.IsFalse(otherTrait.IsFromProperty); Assert.IsTrue(traitCopyFromProperty.IsFromProperty); Assert.AreEqual(3, manifest.ExhibitsTraits.Count); var removed = manifest.ExhibitsTraits.Remove("TraitName"); Assert.IsTrue(removed); Assert.AreEqual(2, manifest.ExhibitsTraits.Count); Assert.AreEqual(trait, manifest.ExhibitsTraits[0]); Assert.AreEqual(otherTrait, manifest.ExhibitsTraits[1]); }
public static CdmTraitReference FromData(CdmCorpusContext ctx, JToken obj) { if (obj == null) { return(null); } bool simpleReference = true; bool? optional = null; dynamic trait; JToken args = null; if (obj is JValue) { trait = obj; } else { simpleReference = false; args = obj["arguments"]; if (obj["optional"] != null) { if (bool.TryParse(obj["optional"].ToString(), out bool optVal)) { optional = optVal; } } if (obj["traitReference"] is JValue) { trait = (string)obj["traitReference"]; } else { trait = TraitPersistence.FromData(ctx, obj["traitReference"]); } } CdmTraitReference traitReference = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, trait, simpleReference); if (optional != null) { traitReference.Optional = optional; } if (args != null) { foreach (var a in args) { traitReference.Arguments.Add(ArgumentPersistence.FromData(ctx, a)); } } return(traitReference); }
/// <summary> /// Validates trait "has.expansionInfo.list" for array type. /// </summary> /// <param name="attribute">The type attribute.</param> /// <param name="expectedAttrName">The expected attribute name.</param> /// <param name="ordinal">The expected ordinal.</param> /// <param name="expansionName">The expected expansion name.</param> /// <param name="memberAttribute">The expected member attribute name.</param> /// <returns></returns> public static void ValidateExpansionInfoTrait(CdmTypeAttributeDefinition attribute, string expectedAttrName, int ordinal, string expansionName, string memberAttribute) { Assert.AreEqual(expectedAttrName, attribute.Name); CdmTraitReference trait = (CdmTraitReference)attribute.AppliedTraits.Item("has.expansionInfo.list"); Assert.IsNotNull(trait); Assert.AreEqual(trait.Arguments.FetchValue("expansionName"), expansionName); Assert.AreEqual(trait.Arguments.FetchValue("ordinal"), ordinal.ToString()); Assert.AreEqual(trait.Arguments.FetchValue("memberAttribute"), memberAttribute); }
public void CollectTraitNames(ResolveOptions resOpt, ISet <string> into) { CdmTraitDefinition currentTrait = this.Trait; while (currentTrait != null) { string name = currentTrait.GetName(); into.Add(name); CdmTraitReference baseRef = currentTrait.ExtendsTrait; currentTrait = baseRef != null?baseRef.FetchObjectDefinition <CdmTraitDefinition>(resOpt) : null; } }
/// <summary> /// Validates that the supporting attribute has the "is.addedInSupportOf" and "is.virtual.attribute" traits /// </summary> /// <param name="supportingAttribute"></param> /// <param name="fromAttribute"></param> private void ValidateInSupportOfAttribute(CdmAttributeItem supportingAttribute, string fromAttribute, bool checkVirtualTrait = true) { CdmTraitReference inSupportOfTrait = supportingAttribute.AppliedTraits.Item("is.addedInSupportOf"); Assert.IsNotNull(inSupportOfTrait); Assert.AreEqual(1, inSupportOfTrait.Arguments.Count); Assert.AreEqual(fromAttribute, inSupportOfTrait.Arguments[0].Value); if (checkVirtualTrait) { Assert.IsNotNull(supportingAttribute.AppliedTraits.Item("is.virtual.attribute"), "Missing is.virtual.attribute traits"); } }
/// <summary> /// Validates trait for map's value or key. /// </summary> /// <param name="attribute">The type attribute.</param> /// <param name="ordinal">The expected ordinal.</param> /// <param name="expansionName">The expected expansion name.</param> /// <param name="memberAttribute">The expected member attribute name.</param> /// <param name="isKey">Whether this is a key.</param> /// <returns></returns> private void ValidateAttributeTrait(CdmTypeAttributeDefinition attribute, string expectedAttrName, int ordinal, string expansionName, string memberAttribute = null, bool isKey = false) { Assert.AreEqual(expectedAttrName, attribute.Name); CdmTraitReference trait = (CdmTraitReference)attribute.AppliedTraits.Item(isKey ? "indicates.expansionInfo.mapKey" : "has.expansionInfo.mapValue"); Assert.IsNotNull(trait); Assert.AreEqual(trait.Arguments.FetchValue("expansionName"), expansionName); Assert.AreEqual(trait.Arguments.FetchValue("ordinal"), ordinal.ToString()); if (memberAttribute != null) { Assert.AreEqual(trait.Arguments.FetchValue("memberAttribute"), memberAttribute); } }
public void Process(TraitAnnotation annotation) { string traitName = annotation.Value; CdmTraitReference trait = corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, traitName, false); foreach (var argument in annotation.Arguments) { if (argument.Value != null) { trait.Arguments.Add(argument.Key, argument.Value); } } entityDefinition.ExhibitsTraits.Add(trait); }
public void CdmTraitCollectionClear() { var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path"); var trait = new CdmTraitReference(manifest.Ctx, "TraitName", false, false); var otherTrait = new CdmTraitReference(manifest.Ctx, "Name of other Trait", false, false); manifest.ExhibitsTraits.Add("trait1"); manifest.ExhibitsTraits.Add("trait2"); manifest.TraitCache = new Dictionary <string, ResolvedTraitSetBuilder>(); manifest.ExhibitsTraits.Clear(); Assert.AreEqual(0, manifest.ExhibitsTraits.Count); Assert.IsNull(manifest.TraitCache); }
public void TestExtendsTraitPropertyOptional() { var corpus = new CdmCorpusDefinition(); var extendTraitRef1 = new CdmTraitReference(corpus.Ctx, "testExtendTraitName1", true, false); var extendTraitRef2 = new CdmTraitReference(corpus.Ctx, "testExtendTraitName2", true, false); var traitDefinition = new CdmTraitDefinition(corpus.Ctx, "testTraitName", extendTraitRef1); Assert.AreEqual(extendTraitRef1, traitDefinition.ExtendsTrait); traitDefinition.ExtendsTrait = null; Assert.IsNull(traitDefinition.ExtendsTrait); traitDefinition.ExtendsTrait = extendTraitRef2; Assert.AreEqual(extendTraitRef2, traitDefinition.ExtendsTrait); traitDefinition.ExtendsTrait = null; Assert.IsNull(traitDefinition.ExtendsTrait); }
public void TestCdmTraitCollectionInsert() { var manifest = CdmCollectionHelperFunctions.GenerateManifest("C:\\Root\\Path"); var trait = new CdmTraitReference(manifest.Ctx, "TraitName", false, false); var otherTrait = new CdmTraitReference(manifest.Ctx, "Name of other Trait", false, false); manifest.TraitCache = new Dictionary <string, ResolvedTraitSetBuilder>(); manifest.ExhibitsTraits.Insert(0, trait); manifest.ExhibitsTraits.Insert(0, otherTrait); Assert.IsNull(manifest.TraitCache); Assert.AreEqual(2, manifest.ExhibitsTraits.Count); Assert.AreEqual(otherTrait, manifest.ExhibitsTraits[0]); Assert.AreEqual(trait, manifest.ExhibitsTraits[1]); Assert.AreEqual(manifest, manifest.ExhibitsTraits[0].Owner); }
public async Task TestReadingIsPrimaryKey() { var testInputPath = TestHelper.GetInputFolderPath(testsSubpath, "TestReadingIsPrimaryKey"); CdmCorpusDefinition corpus = new CdmCorpusDefinition(); corpus.SetEventCallback(new EventCallback { Invoke = CommonDataModelLoader.ConsoleStatusReport }, CdmStatusLevel.Warning); corpus.Storage.Mount("local", new LocalAdapter(testInputPath)); corpus.Storage.DefaultNamespace = "local"; // Read from an unresolved entity schema. CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership.cdm.json/TeamMembership"); CdmAttributeGroupReference attributeGroupRef = (CdmAttributeGroupReference)entity.Attributes[0]; CdmAttributeGroupDefinition attributeGroup = (CdmAttributeGroupDefinition)attributeGroupRef.ExplicitReference; CdmTypeAttributeDefinition typeAttribute = (CdmTypeAttributeDefinition)attributeGroup.Members[0]; Assert.IsTrue((bool)typeAttribute.IsPrimaryKey); // Check that the trait "is.identifiedBy" is created with the correct argument. CdmTraitReference isIdentifiedBy1 = typeAttribute.AppliedTraits[1]; Assert.AreEqual("is.identifiedBy", isIdentifiedBy1.NamedReference); Assert.AreEqual("TeamMembership/(resolvedAttributes)/teamMembershipId", isIdentifiedBy1.Arguments[0].Value); // Read from a resolved entity schema. CdmEntityDefinition resolvedEntity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership_Resolved.cdm.json/TeamMembership"); CdmTypeAttributeDefinition resolvedTypeAttribute = (CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]; Assert.IsTrue((bool)resolvedTypeAttribute.IsPrimaryKey); // Check that the trait "is.identifiedBy" is created with the correct argument. CdmTraitReference isIdentifiedBy2 = resolvedTypeAttribute.AppliedTraits[6]; Assert.AreEqual("is.identifiedBy", isIdentifiedBy2.NamedReference); CdmAttributeReference argumentValue = isIdentifiedBy2.Arguments[0].Value; Assert.AreEqual("TeamMembership/(resolvedAttributes)/teamMembershipId", argumentValue.NamedReference); }
public async Task TestReadingIsPrimaryKey() { CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestReadingIsPrimaryKey"); var resOpt = new ResolveOptions() { StrictValidation = true }; // Read from an unresolved entity schema. CdmEntityDefinition entity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership.cdm.json/TeamMembership", null, resOpt); CdmAttributeGroupReference attributeGroupRef = (CdmAttributeGroupReference)entity.Attributes[0]; CdmAttributeGroupDefinition attributeGroup = (CdmAttributeGroupDefinition)attributeGroupRef.ExplicitReference; CdmTypeAttributeDefinition typeAttribute = (CdmTypeAttributeDefinition)attributeGroup.Members[0]; Assert.IsTrue((bool)typeAttribute.IsPrimaryKey); // Check that the trait "is.identifiedBy" is created with the correct argument. CdmTraitReference isIdentifiedBy1 = typeAttribute.AppliedTraits[1]; Assert.AreEqual("is.identifiedBy", isIdentifiedBy1.NamedReference); Assert.AreEqual("TeamMembership/(resolvedAttributes)/teamMembershipId", isIdentifiedBy1.Arguments[0].Value); // Read from a resolved entity schema. CdmEntityDefinition resolvedEntity = await corpus.FetchObjectAsync <CdmEntityDefinition>("local:/TeamMembership_Resolved.cdm.json/TeamMembership", null, resOpt); CdmTypeAttributeDefinition resolvedTypeAttribute = (CdmTypeAttributeDefinition)resolvedEntity.Attributes[0]; Assert.IsTrue((bool)resolvedTypeAttribute.IsPrimaryKey); // Check that the trait "is.identifiedBy" is created with the correct argument. CdmTraitReference isIdentifiedBy2 = resolvedTypeAttribute.AppliedTraits[6]; Assert.AreEqual("is.identifiedBy", isIdentifiedBy2.NamedReference); CdmAttributeReference argumentValue = isIdentifiedBy2.Arguments[0].Value; Assert.AreEqual("TeamMembership/(resolvedAttributes)/teamMembershipId", argumentValue.NamedReference); }
/// <summary> /// Create an purpose reference instance which points to `meaningOfRelationshipVerbPhrases` which is defined in public standards. /// </summary> /// <param name="cdmCorpus"> The CDM corpus. </param> /// <returns> The instance of purpose reference. </returns> private static CdmPurposeReference CreateRelationshipMeanings(CdmCorpusDefinition cdmCorpus, string customMessage) { // The purpose "meaningOfRelationshipVerbPhrases" is from /samples/example-public-standards/foundations.cdm.json // With the use of this purpose, two additional traits ("means.relationship.verbPhrase" and "means.relationship.inverseVerbPhrase") will be added by default // as they are attached to the purpose definition. CdmPurposeReference purposeRef = cdmCorpus.MakeRef <CdmPurposeReference>(CdmObjectType.PurposeRef, "meaningOfRelationshipVerbPhrases", false); // You can add your own argument to the additional traits // The trait "means.relationship.verbPhrase" is also from /samples/example-public-standards/foundations.cdm.json // This trait states that the data type it requires is an entity "localizedTable", which allow you to define phrases in different languages CdmTraitReference forwardPurposeTraitReference = cdmCorpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "means.relationship.verbPhrase", false); List <List <string> > forwardDescriptions = new List <List <string> > { new List <string>() { "en", $"{customMessage} - Forwards" }, new List <string>() { "cn", "正向" } }; var forwardConstEntDef = cdmCorpus.MakeObject <CdmConstantEntityDefinition>(CdmObjectType.ConstantEntityDef, null, false); forwardConstEntDef.ConstantValues = forwardDescriptions; // The entity "localizedTable" is from /samples/example-public-standards/foundations.cdm.json forwardConstEntDef.EntityShape = cdmCorpus.MakeRef <CdmEntityReference>(CdmObjectType.EntityRef, "localizedTable", true); forwardPurposeTraitReference.Arguments.Add(null, cdmCorpus.MakeRef <CdmEntityReference>(CdmObjectType.EntityRef, forwardConstEntDef, true)); purposeRef.AppliedTraits.Add(forwardPurposeTraitReference); // You can also use the same way above to decorate the second trait "means.relationship.inverseVerbPhrase" // it is also available in /samples/example-public-standards/foundations.cdm.json return(purposeRef); }
/// <summary> /// Checks whether a <see cref="CdmTraitReference"/> is an extension. /// </summary> /// <param name="trait">The trait to be checked whether it is an extension.</param> /// <returns>Whether the trait is an extension.</returns> public static bool TraitRefIsExtension(CdmTraitReference trait) { return(TraitNameHasExtensionMark(trait.NamedReference)); }
private async Task CustomizeEntities(CdmCorpusDefinition cdmCorpus) { // Open the default manifest at the root, used later when done // This method turns relative corpus paths into absolute ones in case we are in some sub-folders and don't know it var manifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("default.manifest.cdm.json"); Console.WriteLine("Define new extension"); // First we will make a new document right in the same folder as the manifest var docAbs = cdmCorpus.MakeObject <CdmDocumentDefinition>(CdmObjectType.DocumentDef, "MobileCareTeam.cdm.json"); // Import the cdm description of the original so the symbols will resolve docAbs.Imports.Add("cdm:/core/applicationCommon/foundationCommon/crmCommon/accelerators/healthCare/electronicMedicalRecords/CareTeam.cdm.json", null); // We will make a new trait to identify things that are known to be temporary, used later // In theory this would be defined somewhere central so it can be shared var traitTemp = docAbs.Definitions.Add(CdmObjectType.TraitDef, "means.temporary") as CdmTraitDefinition; // Extends the standard 'means' base trait traitTemp.ExtendsTrait = cdmCorpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "means", true); // Add a parameter for the expected duration in days var param = cdmCorpus.MakeObject <CdmParameterDefinition>(CdmObjectType.ParameterDef, "estimatedDays"); // By not using "true" on the last arg, this becomes an real reference object in the json. go look at the difference from "means" when this is done param.DataTypeRef = cdmCorpus.MakeObject <CdmDataTypeReference>(CdmObjectType.DataTypeRef, "integer"); param.DefaultValue = "30"; traitTemp.Parameters.Add(param); // Make an entity definition and add it to the list of definitions in the document. CdmEntityDefinition entAbs = docAbs.Definitions.Add(CdmObjectType.EntityDef, "MobileCareTeam") as CdmEntityDefinition; // This entity extends the standard // This function with 'true' will make a simple reference to the base entAbs.ExtendsEntity = cdmCorpus.MakeObject <CdmEntityReference>(CdmObjectType.EntityRef, "CareTeam", true); // and we will add an attribute CdmTypeAttributeDefinition attNew = cdmCorpus.MakeObject <CdmTypeAttributeDefinition>(CdmObjectType.TypeAttributeDef, "currentCity"); // The attribute is a type is 'City" this is one of the predefined semantic types in meanings.cdm.json attNew.DataType = cdmCorpus.MakeObject <CdmDataTypeReference>(CdmObjectType.DataTypeRef, "city", true); attNew.Description = "The current city where the mobile care team is working."; // also apply our fancy new 'temporary' trait. they stay in a city for 90 days on average CdmTraitReference tr = cdmCorpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "means.temporary"); tr.Arguments.Add("estimatedDays", "90"); attNew.AppliedTraits.Add(tr); // Add attribute to the entity entAbs.Attributes.Add(attNew); // The entity abstract definition is done, add the document to the corpus in the root folder and then save that doc cdmCorpus.Storage.FetchRootFolder("local").Documents.Add(docAbs); // next step is to remove all of the guesswork out of decoding the entity shape by 'resolving' it to a relational by reference shape Console.WriteLine("Make a local 'resolved' copy"); // Now resolve it // Made the entity and document have a different name to avoid conflicts in this folder var entFlat = await entAbs.CreateResolvedEntityAsync("LocalMobileCareTeam"); // Now just add the pointer into our manifest. Console.WriteLine("Add to manifest"); manifest.Entities.Add(entFlat); // This function will update all of the fileStatus times in the manifest // await manifest.RefreshAsync(null); // Save the manifest along with linked definition files. await manifest.SaveAsAsync("default-resolved.manifest.cdm.json", true); }
/// <summary> /// Processes extensions from an object which was obtained from a "model.json" file. /// From every extension found, it's value (name, value) is added to traitRefSet, /// and it's definition (name, type) is added to extensionTraitDefList. /// </summary> /// <param name="ctx"> The context </param> /// <param name="sourceObject"> The object obtained from "model.json" file.</param> /// <param name="traitRefSet"> The list of extensions found, in the form of (name & value).</param> /// <param name="extensionTraitDefList"> The list of definitions. For each extension, it's definition is added to this list (name & type).</param> /// <param name="localExtensionTraitDefList"> Same as extensionTraitDefList but limited to extensions inside one document.</param> public static void ProcessExtensionFromJson( CdmCorpusContext ctx, MetadataObject sourceObject, CdmTraitCollection traitRefSet, List <CdmTraitDefinition> extensionTraitDefList, List <CdmTraitDefinition> localExtensionTraitDefList = null) { var extensions = sourceObject.ExtensionFields; foreach (JProperty extensionAsJProperty in extensions.Children()) { string traitName = AddExtensionTraitNamePrefix(extensionAsJProperty.Name); CdmTraitDefinition extensionTraitDef = extensionTraitDefList.Find((CdmTraitDefinition trait) => trait.TraitName == traitName); bool traitExists = extensionTraitDef != null; if (!traitExists) { extensionTraitDef = ctx.Corpus.MakeObject <CdmTraitDefinition>(CdmObjectType.TraitDef, traitName); extensionTraitDef.ExtendsTrait = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "is.extension", true); } CdmTraitReference extensionTraitRef = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, traitName); var extensionValue = extensionAsJProperty.Value; var extensionType = extensionValue.Type; var shouldLookIntoProperties = extensionType == JTokenType.Object; if (shouldLookIntoProperties) { var extensionValueAsJObject = extensionValue as JObject; // extensionProperty.Name is here the equivalent of extensionProperty from TS project foreach (JProperty extensionProperty in extensionValueAsJObject.Children()) { // for every extensionProperty will have to save the (name, value) pair into extensionArgument, // which will be saved in extensionTraitRef (the entity that will contain the data) // (name, type) will be saved in extensionParameter, // which will be saved in extensionTraitDef (the definition of the data, that can be saved in a schema file) JToken extensionPropertyValue = extensionProperty.Value; if (extensionPropertyValue == null) { continue; } CdmArgumentDefinition extensionArgument = ctx.Corpus.MakeObject <CdmArgumentDefinition>( CdmObjectType.ArgumentDef, extensionProperty.Name ); CdmParameterDefinition extensionParameter = extensionTraitDef.Parameters.AllItems.Find( (CdmParameterDefinition parameter) => parameter.Name == extensionProperty.Name); bool parameterExists = extensionParameter != null; if (!parameterExists) { extensionParameter = ctx.Corpus.MakeObject <CdmParameterDefinition>(CdmObjectType.ParameterDef, extensionProperty.Name); extensionParameter.DataTypeRef = ctx.Corpus.MakeObject <CdmDataTypeReference>(CdmObjectType.DataTypeRef, ConvertJTokenTypeToExpectedString(extensionPropertyValue.Type), true); } if (extensionPropertyValue is JValue extensionPropertyValueAsJValue) { extensionArgument.Value = extensionPropertyValueAsJValue.Value; } else { extensionArgument.Value = extensionPropertyValue; } extensionTraitRef.Arguments.Add(extensionArgument); if (!parameterExists) { extensionTraitDef.Parameters.Add(extensionParameter); } } } else { CdmArgumentDefinition extensionArgument = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, traitName); CdmParameterDefinition extensionParameter = extensionTraitDef.Parameters.AllItems.Find((CdmParameterDefinition parameter) => parameter.Name == traitName); bool parameterExists = extensionParameter != null; if (!parameterExists) { extensionParameter = ctx.Corpus.MakeObject <CdmParameterDefinition>(CdmObjectType.ParameterDef, traitName); extensionParameter.DataTypeRef = ctx.Corpus.MakeObject <CdmDataTypeReference>( CdmObjectType.DataTypeRef, ConvertJTokenTypeToExpectedString(extensionType), true); } if (extensionValue is JValue extensionValuePrimite) { extensionArgument.Value = extensionValuePrimite.Value; } else { extensionArgument.Value = extensionValue; } extensionTraitRef.Arguments.Add(extensionArgument); if (!parameterExists) { extensionTraitDef.Parameters.Add(extensionParameter); } } if (!traitExists) { extensionTraitDefList.Add(extensionTraitDef); } if (localExtensionTraitDefList != null) { localExtensionTraitDefList.Add(extensionTraitDef); } traitRefSet.Add(extensionTraitRef); } }
public static dynamic ToData(CdmTraitReference instance, ResolveOptions resOpt, CopyOptions options) { return(CdmObjectRefPersistence.ToData(instance, resOpt, options)); }
static async Task Main(string[] args) { // Make a corpus, the corpus is the collection of all documents and folders created or discovered while navigating objects and paths var cdmCorpus = new CdmCorpusDefinition(); Console.WriteLine("Configure storage adapters"); // Configure storage adapters to point at the target local manifest location and at the fake public standards string pathFromExeToExampleRoot = "../../../../../../"; // Mount is as a local device. cdmCorpus.Storage.Mount("local", new LocalAdapter(pathFromExeToExampleRoot + "3-customize-entities")); cdmCorpus.Storage.DefaultNamespace = "local"; // local is our default. so any paths that start out navigating without a device tag will assume local // Mount it as the 'cdm' device, not the default so must use "cdm:/folder" to get there cdmCorpus.Storage.Mount("cdm", new LocalAdapter(pathFromExeToExampleRoot + "example-public-standards")); // Example how to mount to the ADLS. // cdmCorpus.Storage.Mount("adls", // new ADLSAdapter( // "<ACCOUNT-NAME>.dfs.core.windows.net", // Hostname. // "/<FILESYSTEM-NAME>", // Root. // "72f988bf-86f1-41af-91ab-2d7cd011db47", // Tenant ID. // "<CLIENT-ID>", // Client ID. // "<CLIENT-SECRET>" // Client secret. // )); // Open the default manifest at the root, used later when done // This method turns relative corpus paths into absolute ones in case we are in some sub-folders and don't know it var manifest = await cdmCorpus.FetchObjectAsync <CdmManifestDefinition>("default.folio.cdm.json"); Console.WriteLine("Define new extension"); // First we will make a new document right in the same folder as the manifest var docAbs = cdmCorpus.MakeObject <CdmDocumentDefinition>(CdmObjectType.DocumentDef, "MobileCareTeam.cdm.json"); // Import the cdm description of the original so the symbols will resolve docAbs.Imports.Add("cdm:/core/applicationCommon/foundationCommon/crmCommon/accelerators/healthCare/electronicMedicalRecords/CareTeam.cdm.json", null); // We will make a new trait to identify things that are known to be temporary, used later // In theory this would be defined somewhere central so it can be shared var traitTemp = docAbs.Definitions.Add(CdmObjectType.TraitDef, "means.temporary") as CdmTraitDefinition; // Extends the standard 'means' base trait traitTemp.ExtendsTrait = cdmCorpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "means", true); // Add a parameter for the expected duration in days var param = cdmCorpus.MakeObject <CdmParameterDefinition>(CdmObjectType.ParameterDef, "estimatedDays"); // By not using "true" on the last arg, this becomes an real reference object in the json. go look at the difference from "means" when this is done param.DataTypeRef = cdmCorpus.MakeObject <CdmDataTypeReference>(CdmObjectType.DataTypeRef, "integer"); param.DefaultValue = "30"; traitTemp.Parameters.Add(param); // Make an entity definition and add it to the list of definitions in the document. CdmEntityDefinition entAbs = docAbs.Definitions.Add(CdmObjectType.EntityDef, "MobileCareTeam") as CdmEntityDefinition; // This entity extends the standard // This function with 'true' will make a simple reference to the base entAbs.ExtendsEntity = cdmCorpus.MakeObject <CdmEntityReference>(CdmObjectType.EntityRef, "CareTeam", true); // and we will add an attribute CdmTypeAttributeDefinition attNew = cdmCorpus.MakeObject <CdmTypeAttributeDefinition>(CdmObjectType.TypeAttributeDef, "currentCity"); // The attribute is a type is 'City" this is one of the predefined semantic types in meanings.cdm.json attNew.DataType = cdmCorpus.MakeObject <CdmDataTypeReference>(CdmObjectType.DataTypeRef, "city", true); attNew.Description = "The current city where the mobile care team is working"; // also apply our fancy new 'temporary' trait. they stay in a city for 90 days on average CdmTraitReference tr = cdmCorpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "means.temporary"); tr.Arguments.Add("estimatedDays", "90"); attNew.AppliedTraits.Add(tr); // Add attribute to the entity entAbs.Attributes.Add(attNew); // The entity abstract definition is done, add the document to the corpus in the root folder and then save that doc cdmCorpus.Storage.FetchRootFolder("local").Documents.Add(docAbs); // next step is to remove all of the guesswork out of decoding the entity shape by 'resolving' it to a relational by reference shape Console.WriteLine("Make a local 'resolved' copy"); // Now resolve it // Made the entity and document have a different name to avoid conflicts in this folder var entFlat = await entAbs.CreateResolvedEntityAsync("LocalMobileCareTeam"); // Now just add the pointer into our manifest. Console.WriteLine("Add to manifest"); manifest.Entities.Add(entFlat); // This function will update all of the fileStatus times in the manifest // await manifest.RefreshFileStatus(); // Save the manifest along with linked definition files await manifest.SaveAsAsync("default.manifest.cdm.json", true); }
internal static CdmTraitReference CreateCsvTrait(CsvFormatSettings obj, CdmCorpusContext ctx, CdmTraitReference host = null) { var csvFormatTrait = host ?? ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.partition.format.CSV", false); var argumentNames = new HashSet <string>(csvFormatTrait.Arguments.AllItems.Where(arg => arg.Name != null).Select(arg => arg.Name)); if (obj.ColumnHeaders != null && !argumentNames.Contains("columnHeaders")) { var columnHeadersArg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "columnHeaders"); columnHeadersArg.Value = obj.ColumnHeaders == true ? "true" : "false"; csvFormatTrait.Arguments.Add(columnHeadersArg); } if (obj.CsvStyle != null && !argumentNames.Contains("csvStyle")) { var csvStyleArg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "csvStyle"); csvStyleArg.Value = obj.CsvStyle; csvFormatTrait.Arguments.Add(csvStyleArg); } if (obj.Delimiter != null && !argumentNames.Contains("delimiter")) { var delimiterArg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "delimiter"); delimiterArg.Value = obj.Delimiter; csvFormatTrait.Arguments.Add(delimiterArg); } if (obj.QuoteStyle != null && !argumentNames.Contains("quoteStyle")) { var quoteStyleArg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "quoteStyle"); quoteStyleArg.Value = obj.QuoteStyle; csvFormatTrait.Arguments.Add(quoteStyleArg); } if (obj.Encoding != null && !argumentNames.Contains("encoding")) { var encodingArg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "encoding"); encodingArg.Value = obj.Encoding; csvFormatTrait.Arguments.Add(encodingArg); } return(csvFormatTrait); }
public async static Task <Model> ToData(CdmManifestDefinition instance, ResolveOptions resOpt, CopyOptions options) { var result = new Model() { Name = instance.ManifestName, Description = instance.Explanation, ModifiedTime = instance.LastFileModifiedTime, LastChildFileModifiedTime = instance.LastChildFileModifiedTime, LastFileStatusCheckTime = instance.LastFileStatusCheckTime, DocumentVersion = instance.DocumentVersion }; TraitToPropertyMap t2pm = new TraitToPropertyMap(instance); CdmTraitReference isHiddenTrait = t2pm.FetchTraitReference("is.hidden"); if (isHiddenTrait != null) { result.IsHidden = true; } CdmTraitReference applicationTrait = t2pm.FetchTraitReference("is.managedBy"); if (applicationTrait != null) { result.Application = applicationTrait.Arguments.AllItems[0].Value as string; } CdmTraitReference versionTrait = t2pm.FetchTraitReference("is.modelConversion.modelVersion"); if (versionTrait != null) { result.Version = versionTrait.Arguments.AllItems[0].Value; } else { // version property is required. If it doesn't exist set default. result.Version = "1.0"; } CdmTraitReference cultureTrait = t2pm.FetchTraitReference("is.partition.culture"); if (cultureTrait != null) { result.Culture = cultureTrait.Arguments.AllItems[0].Value as string; } Dictionary <string, string> referenceEntityLocations = new Dictionary <string, string>(); Dictionary <string, string> referenceModels = new Dictionary <string, string>(); CdmTraitReference referenceModelsTrait = t2pm.FetchTraitReference("is.modelConversion.referenceModelMap"); if (referenceModelsTrait != null) { JArray refModels = referenceModelsTrait.Arguments[0].Value as JArray; foreach (JObject referenceModel in refModels) { var referenceModelId = referenceModel["id"]; var referenceModelIdAsString = referenceModelId.ToString(); var referenceModelLocation = referenceModel["location"]; var referenceModelLocationAsString = referenceModelLocation.ToString(); referenceModels.Add(referenceModelIdAsString, referenceModelLocationAsString); referenceEntityLocations.Add(referenceModelLocationAsString, referenceModelIdAsString); } } Utils.ProcessTraitsAndAnnotationsToData(instance.Ctx, result, instance.ExhibitsTraits); if (instance.Entities != null && instance.Entities.Count > 0) { List <Task> promises = new List <Task>(); var obtainedEntities = new ConcurrentBag <JToken>(); foreach (var entity in instance.Entities) { Task createdPromise = Task.Run(async() => { dynamic element = null; if (entity.ObjectType == CdmObjectType.LocalEntityDeclarationDef) { element = await LocalEntityDeclarationPersistence.ToData( entity as CdmLocalEntityDeclarationDefinition, instance, resOpt, options ); } else if (entity.ObjectType == CdmObjectType.ReferencedEntityDeclarationDef) { element = await ReferencedEntityDeclarationPersistence.ToData( entity as CdmReferencedEntityDeclarationDefinition, resOpt, options ); var location = instance.Ctx.Corpus.Storage.CorpusPathToAdapterPath(entity.EntityPath); if (string.IsNullOrEmpty(location)) { Logger.Error(nameof(ManifestPersistence), instance.Ctx, $"Invalid entity path set in entity {entity.EntityName}"); element = null; } if (element is ReferenceEntity referenceEntity) { location = location.Slice(0, location.LastIndexOf("/")); if (referenceEntity.ModelId != null) { if (referenceModels.TryGetValue(referenceEntity.ModelId, out var savedLocation) && savedLocation != location) { Logger.Error(nameof(ManifestPersistence), instance.Ctx, $"Same ModelId pointing to different locations"); element = null; } else if (savedLocation == null) { referenceModels[referenceEntity.ModelId] = location; referenceEntityLocations[location] = referenceEntity.ModelId; } } else if (referenceEntity.ModelId == null && referenceEntityLocations.ContainsKey(location)) { referenceEntity.ModelId = referenceEntityLocations[location]; } else { referenceEntity.ModelId = Guid.NewGuid().ToString(); referenceModels[referenceEntity.ModelId] = location; referenceEntityLocations[location] = referenceEntity.ModelId; } } } if (element != null) { obtainedEntities.Add(JToken.FromObject(element)); } else { Logger.Error(nameof(ManifestPersistence), instance.Ctx, $"There was an error while trying to convert {entity.EntityName}'s entity declaration to model json format."); } }); try { // TODO: Currently function is synchronous. Remove next line to turn it asynchronous. // Currently some functions called are not thread safe. await createdPromise; promises.Add(createdPromise); } catch (Exception ex) { Logger.Error(nameof(ManifestPersistence), instance.Ctx, $"There was an error while trying to convert {entity.EntityName}'s entity declaration to model json format for reason {ex.Message}."); } } await Task.WhenAll(promises); result.Entities = obtainedEntities.ToList(); } if (referenceModels.Count > 0) { result.ReferenceModels = new List <ReferenceModel>(); foreach (var referenceModel in referenceModels) { result.ReferenceModels.Add(new ReferenceModel() { Id = referenceModel.Key, Location = referenceModel.Value }); } } if (instance.Relationships != null && instance.Relationships.Count > 0) { result.Relationships = new List <SingleKeyRelationship>(); foreach (var cdmRelationship in instance.Relationships) { var relationship = await RelationshipPersistence.ToData(cdmRelationship, resOpt, options); if (relationship != null) { result.Relationships.Add(relationship); } else { Logger.Error(nameof(ManifestPersistence), instance.Ctx, "There was an error while trying to convert cdm relationship to model.json relationship."); } } } if (instance.Imports != null && instance.Imports.Count > 0) { result.Imports = new List <Import>(); foreach (var element in instance.Imports) { result.Imports.Add(CdmFolder.ImportPersistence.ToData(element, resOpt, options)); } } return(result); }
internal dynamic FetchDefaultValue(bool onlyFromProperty) { CdmTraitReference trait = this.FetchTraitReference("does.haveDefault", onlyFromProperty); if (trait != null) { var defVal = FetchTraitReferenceArgumentValue(trait as CdmTraitReference, "default"); if (defVal != null) { if (defVal is string) { return(defVal); } if ((defVal as CdmObject).ObjectType == CdmObjectType.EntityRef) { var cEnt = (defVal as CdmObject).FetchObjectDefinition <CdmObjectDefinition>(null) as CdmConstantEntityDefinition; if (cEnt != null) { string esName = cEnt.EntityShape.FetchObjectDefinitionName(); bool corr = esName == "listLookupCorrelatedValues"; bool lookup = esName == "listLookupValues"; if (esName == "localizedTable" || lookup || corr) { List <dynamic> result = new List <dynamic>(); List <List <string> > rawValues = cEnt.ConstantValues; if (rawValues != null) { for (int i = 0; i < rawValues.Count; i++) { Dictionary <string, string> row = new Dictionary <string, string>(); List <string> rawRow = rawValues[i]; if (rawRow.Count == 2 || (lookup && rawRow.Count == 4) || (corr && rawRow.Count == 5)) { row["languageTag"] = rawRow[0]; row["displayText"] = rawRow[1]; if (lookup || corr) { row["attributeValue"] = rawRow[2]; row["displayOrder"] = rawRow[3]; if (corr) { row["correlatedValue"] = rawRow[4]; } } } result.Add(row); } } return(result); } else { // an unknown entity shape. only thing to do is serialize the object defVal = (defVal as CdmObject).CopyData(null, null); } } } else { // is it a cdm object? if (defVal.getObjectType != null) { defVal = (defVal as CdmObject).CopyData(null, null); } } } return(defVal); } return(null); }