public static OperationAddAttributeGroup ToData(CdmOperationAddAttributeGroup instance, ResolveOptions resOpt, CopyOptions options)
{
if (instance == null)
{
return(null);
}
OperationAddAttributeGroup obj = OperationBasePersistence.ToData <OperationAddAttributeGroup>(instance, resOpt, options);
obj.AttributeGroupName = instance.AttributeGroupName;
return(obj);
}
public static CdmOperationAddAttributeGroup FromData(CdmCorpusContext ctx, JToken obj)
{
if (obj == null)
{
return(null);
}
CdmOperationAddAttributeGroup addAttributeGroupOp = OperationBasePersistence.FromData <CdmOperationAddAttributeGroup>(ctx, CdmObjectType.OperationAddAttributeGroupDef, obj);
addAttributeGroupOp.AttributeGroupName = obj["attributeGroupName"]?.ToString();
return(addAttributeGroupOp);
}
public static OperationAddAttributeGroup ToData(CdmOperationAddAttributeGroup instance, ResolveOptions resOpt, CopyOptions options)
{
if (instance == null)
{
return(null);
}
return(new OperationAddAttributeGroup
{
Type = OperationTypeConvertor.OperationTypeToString(CdmOperationType.AddAttributeGroup),
Explanation = instance.Explanation,
// TODO (sukanyas): Property to be defined
});
}
public static OperationAddAttributeGroup ToData(CdmOperationAddAttributeGroup instance, ResolveOptions resOpt, CopyOptions options)
{
if (instance == null)
{
return(null);
}
return(new OperationAddAttributeGroup
{
Type = OperationTypeConvertor.OperationTypeToString(CdmOperationType.AddAttributeGroup),
AttributeGroupName = instance.AttributeGroupName,
Explanation = instance.Explanation
});
}
/// <summary>
/// Applies the replaceAsForeignKey and addAttributeGroup operations to the entity attribute provided.
/// </summary>
/// <param name="entityAttr"></param>
/// <param name="fkAttrName"></param>
/// <param name="attrGroupName"></param>
static void ApplyDefaultBehavior(CdmEntityAttributeDefinition entityAttr, string fkAttrName, string attrGroupName)
{
var ctx = entityAttr.Ctx;
CdmProjection projection = new CdmProjection(ctx)
{
// Link for the Source property documentation.
// https://docs.microsoft.com/en-us/common-data-model/sdk/convert-logical-entities-resolved-entities#source
Source = entityAttr.Entity,
// Link for the RunSequentially property documentation.
// https://docs.microsoft.com/en-us/common-data-model/sdk/convert-logical-entities-resolved-entities#run-sequentially
RunSequentially = true
};
entityAttr.Entity = new CdmEntityReference(ctx, projection, false);
if (fkAttrName != null)
{
var foreignKeyAttr = new CdmTypeAttributeDefinition(ctx, fkAttrName)
{
DataType = new CdmDataTypeReference(ctx, "entityId", true)
};
// Link for the ReplaceAsForeignKey operation documentation.
// https://docs.microsoft.com/en-us/common-data-model/sdk/projections/replaceasforeignkey
var replaceAsFKOperation = new CdmOperationReplaceAsForeignKey(ctx)
{
Condition = "referenceOnly",
Reference = "addressLine",
ReplaceWith = foreignKeyAttr
};
projection.Operations.Add(replaceAsFKOperation);
}
if (attrGroupName != null)
{
// Link for the AddAttributeGroup operation documentation.
// https://docs.microsoft.com/en-us/common-data-model/sdk/projections/addattributegroup
var addAttrGroupOperation = new CdmOperationAddAttributeGroup(ctx)
{
Condition = "structured",
AttributeGroupName = attrGroupName
};
projection.Operations.Add(addAttrGroupOperation);
}
}
public async Task TestEntityAttributeProjUsingObjectModel()
{
string testName = "TestEntityAttributeProjUsingObjectModel";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetCorpus(testName, testsSubpath);
CdmFolderDefinition localRoot = corpus.Storage.FetchRootFolder("local");
// Create an entity
CdmEntityDefinition entity = ProjectionTestUtils.CreateEntity(corpus, localRoot);
// Create a projection
CdmProjection projection = ProjectionTestUtils.CreateProjection(corpus, localRoot);
// Create an AddAttributeGroup operation
CdmOperationAddAttributeGroup addAttGroupOp = corpus.MakeObject <CdmOperationAddAttributeGroup>(CdmObjectType.OperationAddAttributeGroupDef);
addAttGroupOp.AttributeGroupName = "PersonAttributeGroup";
projection.Operations.Add(addAttGroupOp);
// 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);
// Resolve the entity.
CdmEntityDefinition resolvedEntity = await entity.CreateResolvedEntityAsync($"Resolved_{entity.EntityName}.cdm.json", null, localRoot);
// Verify correctness of the resolved attributes after running the AddAttributeGroup operation
// Original set of attributes: ["id", "name", "value", "date"]
CdmAttributeGroupDefinition attGroupDefinition = this.ValidateAttributeGroup(resolvedEntity.Attributes, "PersonAttributeGroup");
Assert.AreEqual(4, attGroupDefinition.Members.Count);
Assert.AreEqual("id", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name", (attGroupDefinition.Members[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("value", (attGroupDefinition.Members[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("date", (attGroupDefinition.Members[3] as CdmTypeAttributeDefinition).Name);
}
public static CdmOperationAddAttributeGroup FromData(CdmCorpusContext ctx, JToken obj)
{
if (obj == null)
{
return(null);
}
CdmOperationAddAttributeGroup addAttributeGroupOp = ctx.Corpus.MakeObject <CdmOperationAddAttributeGroup>(CdmObjectType.OperationAddAttributeGroupDef);
if (obj["$type"] != null && !StringUtils.EqualsWithIgnoreCase(obj["$type"].ToString(), OperationTypeConvertor.OperationTypeToString(CdmOperationType.AddAttributeGroup)))
{
Logger.Error(nameof(OperationAddAttributeGroupPersistence), ctx, $"$type {(string)obj["$type"]} is invalid for this operation.");
}
else
{
addAttributeGroupOp.Type = CdmOperationType.AddAttributeGroup;
}
// TODO (sukanyas): Property to be defined
return(addAttributeGroupOp);
}
public async Task TestConditionalProjUsingObjectModel()
{
string testName = "TestConditionalProjUsingObjectModel";
CdmCorpusDefinition corpus = ProjectionTestUtils.GetCorpus(testName, testsSubpath);
CdmFolderDefinition localRoot = corpus.Storage.FetchRootFolder("local");
// Create an entity.
CdmEntityDefinition entity = ProjectionTestUtils.CreateEntity(corpus, localRoot);
// 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";
// Create an AddAttributeGroup operation
CdmOperationAddAttributeGroup addAttGroupOp = corpus.MakeObject <CdmOperationAddAttributeGroup>(CdmObjectType.OperationAddAttributeGroupDef);
addAttGroupOp.AttributeGroupName = "PersonAttributeGroup";
projection.Operations.Add(addAttGroupOp);
// 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"
})
};
// Resolve the entity with 'referenceOnly'
CdmEntityDefinition resolvedEntityWithReferenceOnly = await entity.CreateResolvedEntityAsync($"Resolved_{entity.EntityName}.cdm.json", resOpt, localRoot);
// Verify correctness of the resolved attributes after running the AddAttributeGroup operation
// Original set of attributes: ["id", "name", "value", "date"]
// Condition not met, keep attributes in flat list
Assert.AreEqual(4, resolvedEntityWithReferenceOnly.Attributes.Count);
Assert.AreEqual("id", (resolvedEntityWithReferenceOnly.Attributes[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name", (resolvedEntityWithReferenceOnly.Attributes[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("value", (resolvedEntityWithReferenceOnly.Attributes[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("date", (resolvedEntityWithReferenceOnly.Attributes[3] as CdmTypeAttributeDefinition).Name);
// Now resolve the entity with the 'structured' directive
resOpt.Directives = new AttributeResolutionDirectiveSet(new HashSet <string> {
"structured"
});
CdmEntityDefinition resolvedEntityWithStructured = await entity.CreateResolvedEntityAsync($"Resolved_{entity.EntityName}.cdm.json", resOpt, localRoot);
// Verify correctness of the resolved attributes after running the AddAttributeGroup operation
// Original set of attributes: ["id", "name", "value", "date"]
// Condition met, put all attributes in an attribute group
CdmAttributeGroupDefinition attGroupDefinition = this.ValidateAttributeGroup(resolvedEntityWithStructured.Attributes, "PersonAttributeGroup");
Assert.AreEqual(4, attGroupDefinition.Members.Count);
Assert.AreEqual("id", (attGroupDefinition.Members[0] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("name", (attGroupDefinition.Members[1] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("value", (attGroupDefinition.Members[2] as CdmTypeAttributeDefinition).Name);
Assert.AreEqual("date", (attGroupDefinition.Members[3] as CdmTypeAttributeDefinition).Name);
}
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;
default:
Logger.Error(nameof(ProjectionPersistence), ctx, $"Invalid operation type '{type}'.", nameof(FromData));
break;
}
}
}
projection.Source = source;
return(projection);
}
