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);
}
