public static CdmOperationAlterTraits FromData(CdmCorpusContext ctx, JToken obj)
{
if (obj == null)
{
return(null);
}
CdmOperationAlterTraits alterTraitsOp = OperationBasePersistence.FromData <CdmOperationAlterTraits>(ctx, CdmObjectType.OperationAlterTraitsDef, obj);
alterTraitsOp.TraitsToAdd = Utils.CreateTraitReferenceList(ctx, obj["traitsToAdd"]);
alterTraitsOp.TraitsToRemove = Utils.CreateTraitReferenceList(ctx, obj["traitsToRemove"]);
alterTraitsOp.ArgumentsContainWildcards = (bool?)obj["argumentsContainWildcards"];
if (obj["applyTo"] is JValue)
{
alterTraitsOp.ApplyTo = new List <string>
{
(string)obj["applyTo"]
};
}
else if (obj["applyTo"] is JArray applyToArray)
{
alterTraitsOp.ApplyTo = applyToArray.ToObject <List <string> >();
}
else if (obj["applyTo"] != null)
{
Logger.Error((ResolveContext)ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistProjUnsupportedProp, "applyTo", "string or list of strings");
return(null);
}
return(alterTraitsOp);
}
public static OperationAlterTraits ToData(CdmOperationAlterTraits instance, ResolveOptions resOpt, CopyOptions options)
{
if (instance == null)
{
return(null);
}
OperationAlterTraits obj = OperationBasePersistence.ToData <OperationAlterTraits>(instance, resOpt, options);
obj.TraitsToAdd = CopyDataUtils.ListCopyData(resOpt, instance.TraitsToAdd, options);
obj.TraitsToRemove = CopyDataUtils.ListCopyData(resOpt, instance.TraitsToRemove, options);
obj.ArgumentsContainWildcards = instance.ArgumentsContainWildcards;
obj.ApplyTo = instance.ApplyTo;
return(obj);
}
public async Task TestConditionalProjUsingObjectModel()
{
string testName = nameof(TestConditionalProjUsingObjectModel);
CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, testName);
CdmFolderDefinition localRoot = corpus.Storage.FetchRootFolder("local");
corpus.Storage.Mount("traitGroup", new LocalAdapter(traitGroupFilePath));
// Create an entity.
CdmEntityDefinition entity = ProjectionTestUtils.CreateEntity(corpus, localRoot);
entity.InDocument.Imports.Add("traitGroup:/TraitGroup.cdm.json");
// Create a projection with a condition that states the operation should only execute when the resolution directive is 'structured'.
CdmProjection projection = ProjectionTestUtils.CreateProjection(corpus, localRoot);
projection.Condition = "structured==true";
projection.RunSequentially = true;
// Create an AlterTraits operation
CdmOperationAlterTraits alterTraitsOp_1 = corpus.MakeObject <CdmOperationAlterTraits>(CdmObjectType.OperationAlterTraitsDef);
alterTraitsOp_1.TraitsToAdd = new CdmCollection <CdmTraitReferenceBase>(corpus.Ctx, alterTraitsOp_1, CdmObjectType.TraitRef);
alterTraitsOp_1.TraitsToAdd.Add(corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "means.TraitG100", true));
alterTraitsOp_1.TraitsToAdd.Add(corpus.MakeRef <CdmTraitGroupReference>(CdmObjectType.TraitGroupRef, "JobTitleBase", true));
alterTraitsOp_1.TraitsToRemove = new CdmCollection <CdmTraitReferenceBase>(corpus.Ctx, alterTraitsOp_1, CdmObjectType.TraitRef);
alterTraitsOp_1.TraitsToRemove.Add(corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "means.TraitG300", true));
projection.Operations.Add(alterTraitsOp_1);
CdmOperationAlterTraits alterTraitsOp_2 = corpus.MakeObject <CdmOperationAlterTraits>(CdmObjectType.OperationAlterTraitsDef);
var traitG4 = corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "means.TraitG4", true);
traitG4.Arguments.Add("precision", "5");
traitG4.Arguments.Add("scale", "15");
alterTraitsOp_2.TraitsToAdd = new CdmCollection <CdmTraitReferenceBase>(corpus.Ctx, alterTraitsOp_2, CdmObjectType.TraitRef);
alterTraitsOp_2.TraitsToAdd.Add(traitG4);
alterTraitsOp_2.ApplyTo = new List <string>()
{
"name"
};
projection.Operations.Add(alterTraitsOp_2);
// Create an entity reference to hold this projection.
CdmEntityReference projectionEntityRef = corpus.MakeObject <CdmEntityReference>(CdmObjectType.EntityRef, null);
projectionEntityRef.ExplicitReference = projection;
// Create an entity attribute that contains this projection and add this to the entity.
CdmEntityAttributeDefinition entityAttribute = corpus.MakeObject <CdmEntityAttributeDefinition>(CdmObjectType.EntityAttributeDef, "TestEntityAttribute");
entityAttribute.Entity = projectionEntityRef;
entity.Attributes.Add(entityAttribute);
// Create resolution options with the 'referenceOnly' directive.
ResolveOptions resOpt = new ResolveOptions(entity.InDocument)
{
Directives = new AttributeResolutionDirectiveSet(new HashSet <string> {
"referenceOnly"
})
};
CdmEntityDefinition resolvedEntityWithReferenceOnly = await entity.CreateResolvedEntityAsync($"Resolved_{entity.EntityName}.cdm.json", resOpt, localRoot);
// Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
// Condition not met, no traits are added
Assert.AreEqual(4, resolvedEntityWithReferenceOnly.Attributes.Count);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntityWithReferenceOnly.Attributes[0], "id", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntityWithReferenceOnly.Attributes[1], "name", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntityWithReferenceOnly.Attributes[2], "value", doesNotExist: true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntityWithReferenceOnly.Attributes[3], "date", doesNotExist: true);
CdmEntityDefinition resolvedEntityWithStructured = await ProjectionTestUtils.GetResolvedEntity(corpus, entity, new List <string> {
"structured"
});
// Original set of attributes: ["name", "age", "address", "phoneNumber", "email"]
// Condition met, new traits are added
Assert.AreEqual(4, resolvedEntityWithStructured.Attributes.Count);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntityWithStructured.Attributes[0], "id");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntityWithStructured.Attributes[1], "name", true);
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntityWithStructured.Attributes[2], "value");
ValidateTrait((CdmTypeAttributeDefinition)resolvedEntityWithStructured.Attributes[3], "date");
}
public static CdmProjection FromData(CdmCorpusContext ctx, JToken obj)
{
if (obj == null)
{
return(null);
}
CdmProjection projection = ctx.Corpus.MakeObject <CdmProjection>(CdmObjectType.ProjectionDef);
CdmEntityReference source = EntityReferencePersistence.FromData(ctx, obj["source"]);
if (obj["explanation"] != null)
{
projection.Explanation = (string)obj["explanation"];
}
projection.Condition = obj["condition"]?.ToString();
projection.RunSequentially = (bool?)obj["runSequentially"];
if (obj["operations"] != null)
{
List <JObject> operationJsons = obj["operations"]?.ToObject <List <JObject> >();
foreach (JObject operationJson in operationJsons)
{
string type = (string)operationJson["$type"];
switch (type)
{
case "addCountAttribute":
CdmOperationAddCountAttribute addCountAttributeOp = OperationAddCountAttributePersistence.FromData(ctx, operationJson);
projection.Operations.Add(addCountAttributeOp);
break;
case "addSupportingAttribute":
CdmOperationAddSupportingAttribute addSupportingAttributeOp = OperationAddSupportingAttributePersistence.FromData(ctx, operationJson);
projection.Operations.Add(addSupportingAttributeOp);
break;
case "addTypeAttribute":
CdmOperationAddTypeAttribute addTypeAttributeOp = OperationAddTypeAttributePersistence.FromData(ctx, operationJson);
projection.Operations.Add(addTypeAttributeOp);
break;
case "excludeAttributes":
CdmOperationExcludeAttributes excludeAttributesOp = OperationExcludeAttributesPersistence.FromData(ctx, operationJson);
projection.Operations.Add(excludeAttributesOp);
break;
case "arrayExpansion":
CdmOperationArrayExpansion arrayExpansionOp = OperationArrayExpansionPersistence.FromData(ctx, operationJson);
projection.Operations.Add(arrayExpansionOp);
break;
case "combineAttributes":
CdmOperationCombineAttributes combineAttributesOp = OperationCombineAttributesPersistence.FromData(ctx, operationJson);
projection.Operations.Add(combineAttributesOp);
break;
case "renameAttributes":
CdmOperationRenameAttributes renameAttributesOp = OperationRenameAttributesPersistence.FromData(ctx, operationJson);
projection.Operations.Add(renameAttributesOp);
break;
case "replaceAsForeignKey":
CdmOperationReplaceAsForeignKey replaceAsForeignKeyOp = OperationReplaceAsForeignKeyPersistence.FromData(ctx, operationJson);
projection.Operations.Add(replaceAsForeignKeyOp);
break;
case "includeAttributes":
CdmOperationIncludeAttributes includeAttributesOp = OperationIncludeAttributesPersistence.FromData(ctx, operationJson);
projection.Operations.Add(includeAttributesOp);
break;
case "addAttributeGroup":
CdmOperationAddAttributeGroup addAttributeGroupOp = OperationAddAttributeGroupPersistence.FromData(ctx, operationJson);
projection.Operations.Add(addAttributeGroupOp);
break;
case "alterTraits":
CdmOperationAlterTraits alterTraitsOp = OperationAlterTraitsPersistence.FromData(ctx, operationJson);
projection.Operations.Add(alterTraitsOp);
break;
case "addArtifactAttribute":
CdmOperationAddArtifactAttribute addArtifactAttributeOp = OperationAddArtifactAttributePersistence.FromData(ctx, operationJson);
projection.Operations.Add(addArtifactAttributeOp);
break;
default:
Logger.Error(ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistProjInvalidOpsType, type);
break;
}
}
}
projection.Source = source;
return(projection);
}
