public void TestCdmCollectionRemoveMethod()
{
var cdmCorpus = new CdmCorpusDefinition();
cdmCorpus.Storage.DefaultNamespace = "local";
cdmCorpus.Storage.Mount("local", new LocalAdapter("CdmCorpus/LocalPath"));
var ctx = cdmCorpus.Ctx;
var cdmDocument = new CdmDocumentDefinition(ctx, "NameOfDocument");
var collection = new CdmCollection <CdmAttributeContext>(ctx, cdmDocument, Enums.CdmObjectType.AttributeContextDef);
var addedDocument = collection.Add("nameOfNewDocument");
var addedDocument2 = collection.Add("otherDocument");
Assert.AreEqual(2, collection.Count);
bool removed = collection.Remove(addedDocument);
Assert.IsTrue(removed);
// try to remove a second time.
removed = collection.Remove(addedDocument);
Assert.IsFalse(removed);
Assert.AreEqual(1, collection.Count);
}
public void TestCdmCollectionRemoveAt()
{
var cdmCorpus = new CdmCorpusDefinition();
cdmCorpus.Storage.DefaultNamespace = "local";
cdmCorpus.Storage.Mount("local", new LocalAdapter("CdmCorpus/LocalPath"));
var ctx = cdmCorpus.Ctx;
var cdmDocument = new CdmDocumentDefinition(ctx, "NameOfDocument");
var collection = new CdmCollection <CdmAttributeContext>(ctx, cdmDocument, Enums.CdmObjectType.AttributeContextDef);
var addedDocument = collection.Add("nameOfNewDocument");
var addedDocument2 = collection.Add("otherDocument");
Assert.AreEqual(2, collection.Count);
collection.RemoveAt(0);
Assert.AreEqual(1, collection.Count);
Assert.AreEqual(addedDocument2, collection[0]);
collection.RemoveAt(1);
Assert.AreEqual(1, collection.Count);
Assert.AreEqual(addedDocument2, collection[0]);
collection.RemoveAt(0);
Assert.AreEqual(0, collection.Count);
}
public void TestCdmCollectionAddMethod()
{
var cdmCorpus = new CdmCorpusDefinition();
cdmCorpus.Storage.DefaultNamespace = "local";
cdmCorpus.Storage.Mount("local", new LocalAdapter("CdmCorpus/LocalPath"));
var ctx = cdmCorpus.Ctx;
var cdmDocument = new CdmDocumentDefinition(ctx, "NameOfDocument");
var collection = new CdmCollection <CdmAttributeContext>(ctx, cdmDocument, Enums.CdmObjectType.AttributeContextDef);
var addedAttributeContext = collection.Add("nameOfNewAttribute");
Assert.AreEqual(1, collection.Count);
Assert.AreEqual("nameOfNewAttribute", collection[0].Name);
Assert.AreEqual(cdmDocument, collection[0].Owner);
Assert.AreEqual(ctx, collection[0].Ctx);
Assert.AreEqual(collection[0], addedAttributeContext);
var attributeContext = new CdmAttributeContext(ctx, "NameOfAttributeContext");
var addedAttribute = collection.Add(attributeContext);
Assert.AreEqual(2, collection.Count);
Assert.AreEqual(attributeContext, addedAttribute);
Assert.AreEqual(attributeContext, collection[1]);
Assert.AreEqual(cdmDocument, attributeContext.Owner);
}
/// <summary>
/// Adds all elements of a list to a CdmCollection
/// </summary>
public static void AddListToCdmCollection <T>(CdmCollection <T> cdmCollection, List <T> list) where T : CdmObject
{
if (cdmCollection != null && list != null)
{
foreach (var element in list)
{
cdmCollection.Add(element);
}
}
}
/// <summary>
/// Get a string version of the relationship collection
/// </summary>
/// <param name="relationships"></param>
/// <returns></returns>
internal static string GetRelationshipStrings(CdmCollection <CdmE2ERelationship> relationships)
{
StringBuilder bldr = new StringBuilder();
foreach (var rel in relationships)
{
bldr.AppendLine($"{rel.Name}|{rel.ToEntity}|{rel.ToEntityAttribute}|{rel.FromEntity}|{rel.FromEntityAttribute}");
}
return(bldr.ToString());
}
/// <summary>
/// Validates the creation of an attribute group and return its definition
/// </summary>
/// <param name="attributes">The collection of attributes.</param>
/// <param name="attributeGroupName">The attribute group name.</param>
/// <param name="attributesSize">The expected size of the attributes collection.</param>
/// <returns></returns>
private CdmAttributeGroupDefinition ValidateAttributeGroup(CdmCollection <CdmAttributeItem> attributes, string attributeGroupName, int attributesSize = 1, int index = 0)
{
Assert.AreEqual(attributesSize, attributes.Count);
Assert.AreEqual(CdmObjectType.AttributeGroupRef, attributes[index].ObjectType);
CdmAttributeGroupReference attGroupReference = attributes[index] as CdmAttributeGroupReference;
Assert.IsNotNull(attGroupReference.ExplicitReference);
CdmAttributeGroupDefinition attGroupDefinition = attGroupReference.ExplicitReference as CdmAttributeGroupDefinition;
Assert.AreEqual(attributeGroupName, attGroupDefinition.AttributeGroupName);
return(attGroupDefinition);
}
/// <summary>
/// Get the traits for all the attributes of a resolved entity
/// </summary>
/// <param name="resolvedEntity"></param>
private void GetTraits(CdmCollection <CdmAttributeItem> attributes)
{
foreach (CdmAttributeItem attrib in attributes)
{
string attribCorpusPath = attrib.AtCorpusPath;
bldr.AppendLine(attribCorpusPath);
if (attrib is CdmAttributeGroupReference)
{
CdmAttributeGroupDefinition attGroupDef = (CdmAttributeGroupDefinition)(attrib as CdmAttributeGroupReference).ExplicitReference;
bldr.AppendLine(attGroupDef.AtCorpusPath);
GetTraitCollection(attGroupDef.ExhibitsTraits);
GetTraits(attGroupDef.Members);
}
else
{
GetTraitCollection(attrib.AppliedTraits);
}
}
}
public void TestCdmCollectionChangeMakesDocumentDirty()
{
var manifest = CdmCollectionHelperFunctions.GenerateManifest();
var collection = new CdmCollection <CdmEntityReference>(manifest.Ctx, manifest, Enums.CdmObjectType.EntityRef);
manifest.IsDirty = false;
collection.Add(new CdmEntityReference(manifest.Ctx, "name", false));
Assert.IsTrue(manifest.IsDirty);
manifest.IsDirty = false;
collection.Add("theName");
Assert.IsTrue(manifest.IsDirty);
var entity = new CdmEntityReference(manifest.Ctx, "otherEntity", false);
var entityList = new List <CdmEntityReference>()
{
entity
};
manifest.IsDirty = false;
collection.AddRange(entityList);
Assert.IsTrue(manifest.IsDirty);
manifest.IsDirty = false;
var entity2 = new CdmEntityReference(manifest.Ctx, "otherEntity2", false);
collection.Insert(0, entity2);
Assert.IsTrue(manifest.IsDirty);
manifest.IsDirty = false;
collection.Remove(entity);
Assert.IsTrue(manifest.IsDirty);
manifest.IsDirty = false;
collection.RemoveAt(0);
Assert.IsTrue(manifest.IsDirty);
manifest.IsDirty = false;
collection.Clear();
Assert.IsTrue(manifest.IsDirty);
}
public void TestCdmCollectionAddingList()
{
var cdmCorpus = new CdmCorpusDefinition();
cdmCorpus.Storage.DefaultNamespace = "local";
cdmCorpus.Storage.Mount("local", new LocalAdapter("CdmCorpus/LocalPath"));
var ctx = cdmCorpus.Ctx;
var cdmDocument = new CdmDocumentDefinition(ctx, "NameOfDocument");
var collection = new CdmCollection <CdmEntityDeclarationDefinition>(ctx, cdmDocument, Enums.CdmObjectType.LocalEntityDeclarationDef);
var entityList = new List <CdmEntityDeclarationDefinition>();
for (int i = 0; i < 2; i++)
{
var entity = new CdmEntityDefinition(cdmCorpus.Ctx, $"entityName_{i}", null);
CdmCollectionHelperFunctions.CreateDocumentForEntity(cdmCorpus, entity);
var entityDeclaration = cdmCorpus.MakeObject <CdmEntityDeclarationDefinition>(Enums.CdmObjectType.LocalEntityDeclarationDef, entity.EntityName, false);
entityDeclaration.Owner = entity.Owner;
entityDeclaration.EntityPath = $"{entity.Owner.AtCorpusPath}/{entity.EntityName}";
entityList.Add(entityDeclaration);
}
Assert.AreEqual(0, collection.Count);
collection.AddRange(entityList);
Assert.AreEqual(2, collection.Count);
for (int i = 0; i < 2; i++)
{
Assert.AreEqual($"entityName_{i}", collection[i].EntityName);
}
}
public static async Task <CdmTypeAttributeDefinition> FromData(CdmCorpusContext ctx, Attribute obj, CdmCollection <CdmTraitDefinition> extensionTraitDefList)
{
var attribute = ctx.Corpus.MakeObject <CdmTypeAttributeDefinition>(CdmObjectType.TypeAttributeDef, obj.Name);
// Do a conversion between CDM data format and model.json data type.
attribute.DataFormat = DataTypeFromData(obj.DataType);
attribute.Description = obj.Description;
if (obj.IsHidden == true)
{
var isHiddenTrait = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "is.hidden");
isHiddenTrait.IsFromProperty = true;
attribute.AppliedTraits.Add(isHiddenTrait);
}
await Utils.ProcessAnnotationsFromData(ctx, obj, attribute.AppliedTraits);
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, attribute.AppliedTraits, extensionTraitDefList);
return(attribute);
}
public static void ValidateAttributesCollection(List <AttributeExpectedValue> expected, CdmCollection <CdmAttributeItem> actual)
{
Assert.AreEqual(expected.Count, actual.Count);
for (int i = 0; i < actual.AllItems.Count; i++)
{
if (actual.AllItems[i].GetType() == typeof(CdmTypeAttributeDefinition))
{
AttributeExpectedValue exp = (AttributeExpectedValue)expected[i];
CdmTypeAttributeDefinition act = (CdmTypeAttributeDefinition)actual.AllItems[i];
ValidateTypeAttributeDefinition(exp, act);
}
else if (actual.AllItems[i].GetType() == typeof(CdmAttributeGroupReference))
{
AttributeExpectedValue exp = (AttributeExpectedValue)expected[i];
CdmAttributeGroupReference act = (CdmAttributeGroupReference)actual.AllItems[i];
ValidateAttributeGroupRef(exp, act);
}
}
}
public static async Task <CdmDataPartitionDefinition> FromData(CdmCorpusContext ctx, Partition obj, CdmCollection <CdmTraitDefinition> extensionTraitDefList)
{
var partition = ctx.Corpus.MakeObject <CdmDataPartitionDefinition>(CdmObjectType.DataPartitionDef, obj.Name);
partition.Description = obj.Description;
partition.Location = ctx.Corpus.Storage.AdapterPathToCorpusPath(obj.Location);
partition.RefreshTime = obj.RefreshTime;
partition.LastFileModifiedTime = obj.LastFileModifiedTime;
partition.LastFileStatusCheckTime = obj.LastFileStatusCheckTime;
if (obj.IsHidden == true)
{
var isHiddenTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.hidden", true);
partition.ExhibitsTraits.Add(isHiddenTrait);
}
await Utils.ProcessAnnotationsFromData(ctx, obj, partition.ExhibitsTraits);
if (obj.FileFormatSettings != null)
{
var csvFormatTrait = Utils.CreateCsvTrait(obj.FileFormatSettings, ctx);
if (csvFormatTrait == null)
{
Logger.Error(typeof(DataPartitionPersistence).ToString(), ctx as ResolveContext, "There was a problem while processing csv format settings inside data partition.");
return(null);
}
partition.ExhibitsTraits.Add(csvFormatTrait);
}
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, partition.ExhibitsTraits, extensionTraitDefList);
return(partition);
}
/// <summary>
/// Adds the remaining definitions of extensions to extensionDoc.
/// Then adds extensionDoc to the folder of the manifest and
/// adds it's path to the list of imports
/// </summary>
/// <param name="ctx">The context</param>
/// <param name="extensionDoc">The document where the definitions will be added. This document will be added to folder and it's path to importDocs</param>
/// <param name="extensionTraitDefList">The list of definitions to be added to schema.</param>
/// <param name="folder">The folder that contains the manifest and where the document containing the schema will be placed.</param>
/// <param name="importDocs">The list of paths of documents containing schemas for the manifest.</param>
private static void CreateExtensionDocAndAddToFolderAndImports(CdmCorpusContext ctx, CdmDocumentDefinition extensionDoc, CdmCollection <CdmTraitDefinition> extensionTraitDefList, CdmFolderDefinition folder, List <CdmImport> importDocs)
{
if (extensionTraitDefList.Count > 0)
{
// pull out the extension trait definitions into a new custom extension document
extensionTraitDefList.Select((CdmTraitDefinition cdmTraitDef) => (CdmObjectDefinition)cdmTraitDef).ToList().ForEach((CdmObjectDefinition cdmObjectDef) =>
{
extensionDoc.Definitions.Add(cdmObjectDef);
});
extensionDoc.Folder = folder;
// import the cdm extensions into this new document that has the custom extensions
CdmImport baseExtensionImport = ctx.Corpus.MakeObject <CdmImport>(CdmObjectType.Import);
baseExtensionImport.CorpusPath = "cdm:/extensions/base.extension.cdm.json";
extensionDoc.Imports.Add(baseExtensionImport);
// add the extension doc to the folder, will wire everything together as needed
folder.Documents.Add(extensionDoc);
// import this new customer extension doc into the list of imports for the origial doc
CdmImport extensionImport = ctx.Corpus.MakeObject <CdmImport>(CdmObjectType.Import);
extensionImport.CorpusPath = ctx.Corpus.Storage.CreateRelativeCorpusPath(extensionDoc.AtCorpusPath, extensionDoc);
importDocs.Add(extensionImport);
}
}
public static async Task <CdmManifestDefinition> FromData(CdmCorpusContext ctx, Model obj, CdmFolderDefinition folder)
{
#region Prepare extenisonDoc
var extensionDoc = ctx.Corpus.MakeObject <CdmDocumentDefinition>(CdmObjectType.DocumentDef,
(string.IsNullOrEmpty(folder.Name) ? folder.Namespace : folder.Name) + ".extension.cdm.json");
CdmCollection <CdmTraitDefinition> extensionTraitDefList = new CdmCollection <CdmTraitDefinition>(ctx, extensionDoc, CdmObjectType.TraitDef);
#endregion
#region Set manifest fields
CdmManifestDefinition manifest = ctx.Corpus.MakeObject <CdmManifestDefinition>(CdmObjectType.ManifestDef, obj.Name);
manifest.Explanation = obj.Description;
manifest.LastFileModifiedTime = obj.ModifiedTime;
manifest.LastChildFileModifiedTime = obj.LastChildFileModifiedTime;
manifest.LastFileStatusCheckTime = obj.LastFileStatusCheckTime;
if (obj.Application != null)
{
var applicationTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.managedBy", false);
applicationTrait.IsFromProperty = true;
var arg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "application");
arg.Value = obj.Application;
applicationTrait.Arguments.Add(arg);
manifest.ExhibitsTraits.Add(applicationTrait);
}
if (obj.Version != null)
{
var versionTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.modelConversion.modelVersion", false);
var arg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "version");
arg.Value = obj.Version;
versionTrait.Arguments.Add(arg);
manifest.ExhibitsTraits.Add(versionTrait);
}
if (obj.Culture != null)
{
var cultureTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.partition.culture", false);
cultureTrait.IsFromProperty = true;
var arg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "culture");
arg.Value = obj.Culture;
cultureTrait.Arguments.Add(arg);
manifest.ExhibitsTraits.Add(cultureTrait);
}
if (obj.IsHidden == true)
{
var isHiddenTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.hidden", true);
isHiddenTrait.IsFromProperty = true;
manifest.ExhibitsTraits.Add(isHiddenTrait);
}
var referenceModels = new Dictionary <string, string>();
if (obj.ReferenceModels != null)
{
var referenceModelsTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.modelConversion.referenceModelMap", false);
var arg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "referenceModelMap");
arg.Value = JToken.FromObject(obj.ReferenceModels);
referenceModelsTrait.Arguments.Add(arg);
manifest.ExhibitsTraits.Add(referenceModelsTrait);
foreach (var referenceModel in obj.ReferenceModels)
{
referenceModels.Add(referenceModel.Id, referenceModel.Location);
}
}
var entitySchemaByName = new Dictionary <string, string>();
if (obj.Entities != null && obj.Entities.Count > 0)
{
foreach (var element in obj.Entities)
{
CdmEntityDeclarationDefinition entity = null;
if ((string)element["$type"] == "LocalEntity")
{
entity = await LocalEntityDeclarationPersistence.FromData(ctx, folder, element.ToObject <LocalEntity>(), extensionTraitDefList);
}
else if ((string)element["$type"] == "ReferenceEntity")
{
var referenceEntity = element.ToObject <ReferenceEntity>();
if (!referenceModels.ContainsKey(referenceEntity.ModelId))
{
Logger.Error(nameof(ManifestPersistence), ctx, $"Model Id {referenceEntity.ModelId} from {referenceEntity.Name} not found in referenceModels.");
return(null);
}
entity = await ReferencedEntityDeclarationPersistence.FromData(ctx, referenceEntity, referenceModels[referenceEntity.ModelId], extensionTraitDefList);
}
else
{
Logger.Error(nameof(ManifestPersistence), ctx, "There was an error while trying to parse entity type.");
}
if (entity != null)
{
manifest.Entities.Add(entity);
if (entity is CdmLocalEntityDeclarationDefinition localEntity)
{
entitySchemaByName.Add(entity.EntityName, localEntity.EntityPath);
}
else if (entity is CdmReferencedEntityDeclarationDefinition referenceEntity)
{
entitySchemaByName.Add(entity.EntityName, referenceEntity.EntityPath);
}
}
else
{
Logger.Error(nameof(ManifestPersistence), ctx, "There was an error while trying to parse entity type.");
}
}
}
if (obj.Relationships != null && obj.Relationships.Count > 0)
{
foreach (var element in obj.Relationships)
{
var relationship = await RelationshipPersistence.FromData(ctx, element, entitySchemaByName);
if (relationship != null)
{
manifest.Relationships.Add(relationship);
}
else
{
Logger.Error(nameof(ManifestPersistence), ctx, "There was an error while trying to convert model.json local entity to cdm local entity declaration.");
}
}
}
if (obj.Imports != null)
{
foreach (var element in obj.Imports)
{
manifest.Imports.Add(CdmFolder.ImportPersistence.FromData(ctx, element));
}
}
await Utils.ProcessAnnotationsFromData(ctx, obj, manifest.ExhibitsTraits);
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, manifest.ExhibitsTraits, extensionTraitDefList);
#endregion
#region Use extensionDoc, finalize importDocs
List <CdmImport> importDocs = await ExtensionHelper.StandardImportDetection(ctx, extensionTraitDefList);
CreateExtensionDocAndAddToFolderAndImports(ctx, extensionDoc, extensionTraitDefList, folder, importDocs);
await AddImportDocsToManifest(ctx, importDocs, manifest);
#endregion
// We need to set up folder path and namespace of a manifest to be able to retrieve that object.
folder.Documents.Add(manifest);
return(manifest);
}
public static async Task <CdmEntityDefinition> FromData(CdmCorpusContext ctx, LocalEntity obj, CdmCollection <CdmTraitDefinition> extensionTraitDefList)
{
var entity = ctx.Corpus.MakeObject <CdmEntityDefinition>(CdmObjectType.EntityDef, obj.Name);
entity.Description = obj.Description;
await Utils.ProcessAnnotationsFromData(ctx, obj, entity.ExhibitsTraits);
if (obj.Attributes != null)
{
foreach (dynamic attribute in obj.Attributes)
{
var typeAttribute = await TypeAttributePersistence.FromData(ctx, attribute, extensionTraitDefList);
if (typeAttribute != null)
{
entity.Attributes.Add(typeAttribute);
}
else
{
Logger.Error(nameof(EntityPersistence), (ResolveContext)ctx, "There was an error while trying to convert model.json attribute to cdm attribute.");
return(null);
}
}
}
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, entity.ExhibitsTraits, extensionTraitDefList);
return(entity);
}
public static async Task <CdmDocumentDefinition> FromData(CdmCorpusContext ctx, LocalEntity obj, CdmCollection <CdmTraitDefinition> extensionTraitDefList)
{
var docName = $"{obj.Name}.cdm.json";
var document = ctx.Corpus.MakeObject <CdmDocumentDefinition>(CdmObjectType.DocumentDef, docName);
// import at least foundations
var foundationsImport = ctx.Corpus.MakeObject <CdmImport>(CdmObjectType.Import);
foundationsImport.CorpusPath = "cdm:/foundations.cdm.json";
document.Imports.Add(foundationsImport);
var entity = await EntityPersistence.FromData(ctx, obj, extensionTraitDefList);
if (entity == null)
{
Logger.Error(nameof(DocumentPersistence), ctx, "There was an error while trying to convert a model.json entity to the CDM entity.");
return(null);
}
if (obj.Imports != null)
{
foreach (var import in obj.Imports)
{
if (import.CorpusPath?.Equals("cdm:/foundations.cdm.json") == true)
{
// don't add foundations twice
continue;
}
document.Imports.Add(CdmFolder.ImportPersistence.FromData(ctx, import));
}
}
document.Definitions.Add(entity);
return(document);
}
public static async Task <CdmLocalEntityDeclarationDefinition> FromData(CdmCorpusContext ctx, CdmFolderDefinition documentFolder, LocalEntity obj, CdmCollection <CdmTraitDefinition> extensionTraitDefList)
{
var localEntity = ctx.Corpus.MakeObject <CdmLocalEntityDeclarationDefinition>(CdmObjectType.LocalEntityDeclarationDef, obj.Name);
var entityDoc = await DocumentPersistence.FromData(ctx, obj, extensionTraitDefList);
if (entityDoc == null)
{
Logger.Error(nameof(LocalEntityDeclarationPersistence), ctx, "There was an error while trying to fetch the entity doc from local entity declaration persistence.");
return(null);
}
documentFolder.Documents.Add(entityDoc);
// Entity schema path is the path to the doc containing the entity definition.
localEntity.EntityPath = ctx.Corpus.Storage.CreateRelativeCorpusPath($"{entityDoc.AtCorpusPath}/{obj.Name}", entityDoc);
localEntity.Explanation = obj.Description;
localEntity.LastChildFileModifiedTime = obj.LastChildFileModifiedTime;
localEntity.LastFileModifiedTime = obj.LastFileModifiedTime;
localEntity.LastFileStatusCheckTime = obj.LastFileStatusCheckTime;
if (obj.IsHidden == true)
{
var isHiddenTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.hidden", true);
isHiddenTrait.IsFromProperty = true;
localEntity.ExhibitsTraits.Add(isHiddenTrait);
}
// Add traits for schema entity info.
if (obj.Schemas != null)
{
var t2pm = new TraitToPropertyMap(localEntity);
t2pm.UpdatePropertyValue("cdmSchemas", obj.Schemas);
}
// Data partitions are part of the local entity, add them here.
if (obj.Partitions != null)
{
foreach (var element in obj.Partitions)
{
var cdmPartition = await DataPartitionPersistence.FromData(ctx, element, extensionTraitDefList);
if (cdmPartition != null)
{
localEntity.DataPartitions.Add(cdmPartition);
}
else
{
Logger.Error(nameof(LocalEntityDeclarationPersistence), ctx, "There was an error while trying to fetch the entity doc from local entity declaration persistence.");
return(null);
}
}
}
return(localEntity);
}
/// <summary>
/// For all the definitions (name, type) we have found for extensions, search in CDM Standard Schema for definition files.
/// If we find a definition in a CDM Standard Schema file, we add that file to importsList.
/// At the same time, the found definition is removed from extensionTraitDefList.
/// When this function returns, extensionTraitDefList only contains definitions that are not present in any CDM Standard Schema file,
/// and a list of CDM Standard Schema files with relevant definitions is returned.
/// </summary>
/// <param name="ctx"> The context</param>
/// <param name="extensionTraitDefList"> The list of all definitions for all found extensions. Function modifies this list by removing definitions found in CDM Standard Schema files.</param>
/// <returns> A list of CDM Standard Schema files to import.</returns>
public static async Task <List <CdmImport> > StandardImportDetection(CdmCorpusContext ctx, CdmCollection <CdmTraitDefinition> extensionTraitDefList)
{
List <CdmImport> importsList = new List <CdmImport>();
// have to go from end to start because I might remove elements
for (int traitIndex = extensionTraitDefList.Count - 1; traitIndex >= 0; traitIndex--)
{
CdmTraitDefinition extensionTraitDef = extensionTraitDefList[traitIndex];
if (!TraitDefIsExtension(extensionTraitDef))
{
Logger.Error(nameof(ExtensionHelper), ctx, $"Invalid extension trait name {extensionTraitDef.TraitName}, expected prefix {ExtensionTraitNamePrefix}.");
return(null);
}
string[] extensionBreakdown = RemoveExtensionTraitNamePrefix(extensionTraitDef.TraitName).Split(':');
if (extensionBreakdown.Length > 1)
{
string extensionName = extensionBreakdown[0];
string fileName = $"{extensionName}.extension.cdm.json";
string fileCorpusPath = $"cdm:/extensions/{fileName}";
CdmDocumentDefinition extensionDoc = await FetchDefDoc(ctx, fileName);
// If no document was found for that extensionName, the trait does not have a document with it's definition.
// Trait will be kept in extensionTraitDefList (a document with its definition will be created locally)
if (extensionDoc == null)
{
continue;
}
// There is a document with extensionName, now we search for the trait in the document.
// If we find it, we remove the trait from extensionTraitDefList and add the document to imports.
CdmTraitDefinition matchingTrait = extensionDoc.Definitions.AllItems.Find(
(definition) => definition.ObjectType == CdmObjectType.TraitDef && definition.GetName() == extensionTraitDef.TraitName)
as CdmTraitDefinition;
if (matchingTrait != null)
{
List <CdmParameterDefinition> parameterList = matchingTrait.Parameters.AllItems;
if (
extensionTraitDef.Parameters.AllItems.TrueForAll(
(CdmParameterDefinition extensionParameter) =>
parameterList.Exists(
(CdmParameterDefinition defParameter) => defParameter.Name == extensionParameter.Name)
)
)
{
extensionTraitDefList.Remove(extensionTraitDefList[traitIndex]);
if (!importsList.Exists((CdmImport importDoc) => importDoc.CorpusPath == fileCorpusPath))
{
CdmImport importObject = ctx.Corpus.MakeObject <CdmImport>(CdmObjectType.Import);
importObject.CorpusPath = fileCorpusPath;
importsList.Add(importObject);
}
}
}
}
}
return(importsList);
}
/// <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>
public static void ProcessExtensionFromJson(
CdmCorpusContext ctx,
MetadataObject sourceObject,
CdmTraitCollection traitRefSet,
CdmCollection <CdmTraitDefinition> extensionTraitDefList)
{
var extensions = sourceObject.ExtensionFields;
foreach (JProperty extensionAsJProperty in extensions.Children())
{
string traitName = AddExtensionTraitNamePrefix(extensionAsJProperty.Name);
CdmTraitReference extensionTraitRef = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, traitName);
CdmTraitDefinition extensionTraitDef = extensionTraitDefList.AllItems.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);
}
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);
}
extensionArgument.Value = extensionValue;
extensionTraitRef.Arguments.Add(extensionArgument);
if (!parameterExists)
{
extensionTraitDef.Parameters.Add(extensionParameter);
}
}
if (!traitExists)
{
extensionTraitDefList.Add(extensionTraitDef);
}
traitRefSet.Add(extensionTraitRef);
}
}
public static async Task <CdmReferencedEntityDeclarationDefinition> FromData(CdmCorpusContext ctx, ReferenceEntity obj, string location, CdmCollection <CdmTraitDefinition> extensionTraitDefList)
{
var referencedEntity = ctx.Corpus.MakeObject <CdmReferencedEntityDeclarationDefinition>(CdmObjectType.ReferencedEntityDeclarationDef, obj.Name);
var corpusPath = ctx.Corpus.Storage.AdapterPathToCorpusPath(location);
referencedEntity.EntityName = obj.Name;
referencedEntity.EntityPath = $"{corpusPath}/{obj.Source}";
referencedEntity.Explanation = obj.Description;
referencedEntity.LastFileModifiedTime = obj.LastFileModifiedTime;
referencedEntity.LastFileStatusCheckTime = obj.LastFileStatusCheckTime;
await Utils.ProcessAnnotationsFromData(ctx, obj, referencedEntity.ExhibitsTraits);
if (obj.IsHidden == true)
{
var isHiddenTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.hidden", true);
isHiddenTrait.IsFromProperty = true;
referencedEntity.ExhibitsTraits.Add(isHiddenTrait);
}
var trait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.propertyContent.multiTrait", true);
trait.SimpleNamedReference = false;
trait.IsFromProperty = true;
var argument = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "modelId");
argument.Value = obj.ModelId;
trait.Arguments.Add(argument);
referencedEntity.ExhibitsTraits.Add(trait);
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, referencedEntity.ExhibitsTraits, extensionTraitDefList);
return(referencedEntity);
}
