public static async Task <CdmTypeAttributeDefinition> FromData(CdmCorpusContext ctx, Attribute obj, List <CdmTraitDefinition> extensionTraitDefList, List <CdmTraitDefinition> localExtensionTraitDefList)
{
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);
if (!string.IsNullOrWhiteSpace(obj.Description))
{
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, localExtensionTraitDefList);
return(attribute);
}
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);
}
public static async Task <CdmEntityDefinition> FromData(CdmCorpusContext ctx, LocalEntity obj, List <CdmTraitDefinition> extensionTraitDefList, List <CdmTraitDefinition> localExtensionTraitDefList)
{
var entity = ctx.Corpus.MakeObject <CdmEntityDefinition>(CdmObjectType.EntityDef, obj.Name);
if (!string.IsNullOrWhiteSpace(obj.Description))
{
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, localExtensionTraitDefList);
if (typeAttribute != null)
{
entity.Attributes.Add(typeAttribute);
}
else
{
Logger.Error((ResolveContext)ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistModelJsonToAttrConversionFailure);
return(null);
}
}
}
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, entity.ExhibitsTraits, extensionTraitDefList, localExtensionTraitDefList);
return(entity);
}
public static async Task <CdmEntityDefinition> FromData(CdmCorpusContext ctx, LocalEntity obj, List <CdmTraitDefinition> extensionTraitDefList, List <CdmTraitDefinition> localExtensionTraitDefList)
{
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, localExtensionTraitDefList);
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, localExtensionTraitDefList);
return(entity);
}
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);
}
internal static async Task ProcessTraitsAndAnnotationsToData(CdmCorpusContext ctx, MetadataObject obj, CdmTraitCollection traits)
{
if (traits == null)
{
return;
}
var annotations = new List <Annotation>();
var extensions = new List <JToken>();
foreach (var trait in traits)
{
if (ExtensionHelper.TraitRefIsExtension(trait))
{
ExtensionHelper.ProcessExtensionTraitToObject(trait, obj);
continue;
}
if (trait.NamedReference == "is.modelConversion.otherAnnotations")
{
foreach (var annotation in trait.Arguments[0].Value)
{
if (annotation is JObject jAnnotation)
{
annotations.Add(jAnnotation.ToObject <Annotation>());
}
else if (annotation is Annotation)
{
annotations.Add(annotation);
}
else
{
Logger.Warning(nameof(Utils), ctx, "Unsupported annotation type.");
}
}
}
else if (
!ignoredTraits.Contains(trait.NamedReference) &&
!trait.NamedReference.StartsWith("is.dataFormat") &&
!(modelJsonPropertyTraits.Contains(trait.NamedReference) && trait.IsFromProperty))
{
var extension = CdmFolder.TraitReferencePersistence.ToData(trait, null, null);
extensions.Add(JToken.FromObject(extension, JsonSerializationUtil.JsonSerializer));
}
}
if (annotations.Count > 0)
{
obj.Annotations = annotations;
}
if (extensions.Count > 0)
{
obj.Traits = extensions;
}
}
public static async Task <CdmLocalEntityDeclarationDefinition> FromData(CdmCorpusContext ctx, CdmFolderDefinition documentFolder, LocalEntity obj, List <CdmTraitDefinition> extensionTraitDefList, CdmManifestDefinition manifest)
{
var localEntity = ctx.Corpus.MakeObject <CdmLocalEntityDeclarationDefinition>(CdmObjectType.LocalEntityDeclarationDef, obj.Name);
var localExtensionTraitDefList = new List <CdmTraitDefinition>();
var entityDoc = await DocumentPersistence.FromData(ctx, obj, extensionTraitDefList, localExtensionTraitDefList);
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}", manifest);
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, localExtensionTraitDefList, documentFolder);
if (cdmPartition != null)
{
localEntity.DataPartitions.Add(cdmPartition);
}
else
{
Logger.Error((ResolveContext)ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistModelJsonDocConversionError);
return(null);
}
}
}
List <CdmImport> importDocs = await ExtensionHelper.StandardImportDetection(ctx, extensionTraitDefList, localExtensionTraitDefList);
ExtensionHelper.AddImportDocsToManifest(ctx, importDocs, entityDoc);
return(localEntity);
}
public static async Task <CdmDataPartitionDefinition> FromData(CdmCorpusContext ctx, Partition obj, List <CdmTraitDefinition> extensionTraitDefList, List <CdmTraitDefinition> localExtensionTraitDefList, CdmFolderDefinition documentFolder)
{
var partition = ctx.Corpus.MakeObject <CdmDataPartitionDefinition>(CdmObjectType.DataPartitionDef, obj.Name);
if (!StringUtils.IsBlankByCdmStandard(obj.Description))
{
partition.Description = obj.Description;
}
partition.Location = ctx.Corpus.Storage.CreateRelativeCorpusPath(
ctx.Corpus.Storage.AdapterPathToCorpusPath(obj.Location),
documentFolder);
partition.RefreshTime = obj.RefreshTime;
partition.LastFileModifiedTime = obj.LastFileModifiedTime;
partition.LastFileStatusCheckTime = obj.LastFileStatusCheckTime;
if (StringUtils.IsBlankByCdmStandard(partition.Location))
{
Logger.Warning(ctx as ResolveContext, Tag, nameof(FromData), null, CdmLogCode.WarnPersistPartitionLocMissing, partition.Name);
}
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);
var csvFormatTrait = partition.ExhibitsTraits.Item("is.partition.format.CSV") as CdmTraitReference;
if (obj.FileFormatSettings != null)
{
var partitionTraitExisted = csvFormatTrait != null;
csvFormatTrait = Utils.CreateCsvTrait(obj.FileFormatSettings, ctx, csvFormatTrait);
if (csvFormatTrait == null)
{
Logger.Error(ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistCsvProcessingError);
return(null);
}
if (!partitionTraitExisted)
{
partition.ExhibitsTraits.Add(csvFormatTrait);
}
}
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, partition.ExhibitsTraits, extensionTraitDefList, localExtensionTraitDefList);
return(partition);
}
public static async Task <CdmReferencedEntityDeclarationDefinition> FromData(CdmCorpusContext ctx, ReferenceEntity obj, string location)
{
var referencedEntity = ctx.Corpus.MakeObject <CdmReferencedEntityDeclarationDefinition>(CdmObjectType.ReferencedEntityDeclarationDef, obj.Name);
referencedEntity.EntityName = obj.Name;
var corpusPath = ctx.Corpus.Storage.AdapterPathToCorpusPath(location);
if (corpusPath == null)
{
Logger.Error((ResolveContext)ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistModelJsonRefEntityInvalidLocation, location, referencedEntity.EntityName);
return(null);
}
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", 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);
var extensionTraitDefList = new List <CdmTraitDefinition>();
var extensionTraits = new CdmTraitCollection(ctx, referencedEntity);
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, extensionTraits, extensionTraitDefList);
if (extensionTraitDefList.Count > 0)
{
Logger.Warning(ctx, Tag, nameof(FromData), null, CdmLogCode.WarnPersistCustomExtNotSupported, referencedEntity.EntityName);
}
return(referencedEntity);
}
public static async Task <CdmDataPartitionDefinition> FromData(CdmCorpusContext ctx, Partition obj, List <CdmTraitDefinition> extensionTraitDefList, List <CdmTraitDefinition> localExtensionTraitDefList, CdmFolderDefinition documentFolder)
{
var partition = ctx.Corpus.MakeObject <CdmDataPartitionDefinition>(CdmObjectType.DataPartitionDef, obj.Name);
if (!string.IsNullOrWhiteSpace(obj.Description))
{
partition.Description = obj.Description;
}
partition.Location = ctx.Corpus.Storage.CreateRelativeCorpusPath(
ctx.Corpus.Storage.AdapterPathToCorpusPath(obj.Location),
documentFolder);
partition.RefreshTime = obj.RefreshTime;
partition.LastFileModifiedTime = obj.LastFileModifiedTime;
partition.LastFileStatusCheckTime = obj.LastFileStatusCheckTime;
if (string.IsNullOrEmpty(partition.Location))
{
Logger.Warning(nameof(DataPartitionPersistence), ctx as ResolveContext, $"Couldn't find data partition's location for partition {partition.Name}.", nameof(FromData));
}
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(nameof(DataPartitionPersistence), 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, localExtensionTraitDefList);
return(partition);
}
public static async Task <CdmManifestDefinition> FromObject(CdmCorpusContext ctx, Model obj, CdmFolderDefinition folder)
{
#region Prepare extensionDoc
List <CdmTraitDefinition> extensionTraitDefList = new List <CdmTraitDefinition>();
#endregion
#region Set manifest fields
CdmManifestDefinition manifest = ctx.Corpus.MakeObject <CdmManifestDefinition>(CdmObjectType.ManifestDef, obj.Name);
// We need to set up folder path and namespace of a manifest to be able to retrieve that object.
folder.Documents.Add(manifest);
if (obj.Imports != null)
{
foreach (var element in obj.Imports)
{
manifest.Imports.Add(CdmFolder.ImportPersistence.FromData(ctx, element));
}
}
if (!manifest.Imports.Any((CdmImport importPresent) => importPresent.CorpusPath == "cdm:/foundations.cdm.json"))
{
manifest.Imports.Add("cdm:/foundations.cdm.json");
}
manifest.Explanation = obj.Description;
manifest.LastFileModifiedTime = obj.ModifiedTime;
manifest.LastChildFileModifiedTime = obj.LastChildFileModifiedTime;
manifest.LastFileStatusCheckTime = obj.LastFileStatusCheckTime;
if (!string.IsNullOrEmpty(obj.DocumentVersion))
{
manifest.DocumentVersion = obj.DocumentVersion;
}
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, manifest);
}
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]);
}
else
{
Logger.Error(nameof(ManifestPersistence), ctx, "There was an error while trying to parse entity type.");
}
if (entity != null)
{
manifest.Entities.Add(entity);
entitySchemaByName.Add(entity.EntityName, entity.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.Warning(nameof(ManifestPersistence), ctx, "There was an issue while trying to read relationships from the model.json file.");
}
}
}
await Utils.ProcessAnnotationsFromData(ctx, obj, manifest.ExhibitsTraits);
var localExtensionTraitDefList = new List <CdmTraitDefinition>();
ExtensionHelper.ProcessExtensionFromJson(ctx, obj, manifest.ExhibitsTraits, extensionTraitDefList, localExtensionTraitDefList);
#endregion
#region Use extensionDoc, finalize importDocs
List <CdmImport> importDocs = await ExtensionHelper.StandardImportDetection(ctx, extensionTraitDefList, localExtensionTraitDefList);
ExtensionHelper.AddImportDocsToManifest(ctx, importDocs, manifest);
CreateExtensionDocAndAddToFolderAndImports(ctx, extensionTraitDefList, folder);
#endregion
return(manifest);
}
internal static void ProcessTraitsAndAnnotationsToData(CdmCorpusContext ctx, MetadataObject obj, CdmTraitCollection traits)
{
if (traits == null)
{
return;
}
var annotations = new List <Annotation>();
var extensions = new List <JToken>();
foreach (var trait in traits)
{
if (ExtensionHelper.TraitRefIsExtension(trait))
{
// Safe to cast since extensions can only be trait refs, not trait group refs
ExtensionHelper.ProcessExtensionTraitToObject(trait as CdmTraitReference, obj);
continue;
}
if (trait.NamedReference == "is.modelConversion.otherAnnotations")
{
// Safe to cast since "is.modelConversion.otherAnnotations" is a trait, not trait group
foreach (var annotation in (trait as CdmTraitReference).Arguments[0].Value)
{
if (annotation is JObject jAnnotation)
{
annotations.Add(jAnnotation.ToObject <Annotation>());
}
else if (annotation is NameValuePair)
{
Annotation element = new Annotation()
{
Name = annotation.Name,
Value = annotation.Value
};
annotations.Add(element);
}
else
{
Logger.Warning(ctx, Tag, nameof(ProcessTraitsAndAnnotationsToData), null, CdmLogCode.WarnAnnotationTypeNotSupported);
}
}
}
else if (
!ignoredTraits.Contains(trait.NamedReference) &&
!trait.NamedReference.StartsWith("is.dataFormat") &&
!(modelJsonPropertyTraits.Contains(trait.NamedReference) && trait is CdmTraitReference && (trait as CdmTraitReference).IsFromProperty))
{
var extension = trait is CdmTraitGroupReference?
CdmFolder.TraitGroupReferencePersistence.ToData(trait as CdmTraitGroupReference, null, null) :
CdmFolder.TraitReferencePersistence.ToData(trait as CdmTraitReference, null, null);
extensions.Add(JToken.FromObject(extension, JsonSerializationUtil.JsonSerializer));
}
}
if (annotations.Count > 0)
{
obj.Annotations = annotations;
}
if (extensions.Count > 0)
{
obj.Traits = extensions;
}
}
