private bool IsIncluded(ResourceClassBase resource, ResourceMemberBase resourceMember)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (resourceMember == null)
{
throw new ArgumentNullException(nameof(resourceMember));
}
if (!HasProfile)
{
return(true);
}
if (!IsIncluded(resource))
{
return(false);
}
if (resource.Name == SuppliedResource.Name)
{
return(SuppliedResource.AllMembers.Any(x => x.PropertyName == resourceMember.PropertyName));
}
var filteredResource = GetContainedResource(resource);
return(filteredResource != null &&
filteredResource.AllMembers.Any(x => x.PropertyName == resourceMember.PropertyName));
}
public CompositeDefinitionProcessorContext(
XElement compositeDefinitionElement,
IResourceModel resourceModel,
XElement currentElement,
ResourceClassBase currentResourceClass,
AssociationView joinAssociation,
string entityMemberName,
string memberDisplayName,
int childIndex,
ResourceMemberBase resourceMember)
{
ChildIndex = childIndex;
CurrentResourceMember = resourceMember;
CompositeDefinitionElement = compositeDefinitionElement;
ResourceModel = resourceModel;
CurrentElement = currentElement;
CurrentResourceClass = currentResourceClass;
JoinAssociation = joinAssociation;
EntityMemberName = entityMemberName;
MemberDisplayName = memberDisplayName;
}
/// <summary>
/// Applies the provided flattened resource reference to the build result using the suplied builder context.
/// </summary>
/// <param name="member">The flattened ReferencedResource or EmbeddedObject to be applied to the build result.</param>
/// <param name="builderContext">The builder context.</param>
public void ApplyFlattenedMember(
ResourceMemberBase member,
HqlBuilderContext builderContext)
{
var downCastedReference = member as Reference;
var downCastedEmbeddedObject = member as EmbeddedObject;
var downCastedResourceProperty = member as ResourceProperty;
string associationName =
downCastedReference?.Association?.Name
?? downCastedEmbeddedObject?.Association?.Name
?? downCastedResourceProperty?.PropertyName;
// Create a new alias
builderContext.CurrentAlias = builderContext.AliasGenerator.GetNextAlias();
// Add the connective HQL join for processing the flattened reference
builderContext.From.AppendFormat(
"{0}\tjoin {1}.{2} {3}",
Environment.NewLine,
builderContext.ParentAlias,
associationName,
builderContext.CurrentAlias);
}
/// <summary>
/// Applies the provided flattened resource reference to the build result using the suplied builder context.
/// </summary>
/// <param name="member">The flattened ReferencedResource or EmbeddedObject to be applied to the build result.</param>
/// <param name="builderContext">The builder context.</param>
public void ApplyFlattenedMember(ResourceMemberBase member, HqlBuilderContext builderContext)
{
_next.ApplyFlattenedMember(member, builderContext);
}
/// <summary>
/// Applies the provided flattened resource reference to the build result using the supplied builder context.
/// </summary>
/// <param name="member">The flattened ReferencedResource or EmbeddedObject to be applied to the build result.</param>
/// <param name="builderContext">The builder context.</param>
public void ApplyFlattenedMember(ResourceMemberBase member, CompositeResourceModelBuilderContext builderContext)
{
// Nothing to do
}
private void ProcessFlattenedMemberProperties(
CompositeDefinitionProcessorContext processorContext,
TBuilderContext builderContext)
{
string currentContainingElementName = processorContext.CurrentElement.AttributeValue(CompositeDefinitionHelper.Name);
var flattenedMemberElements = processorContext.CurrentElement
.Elements(CompositeDefinitionHelper.ReferencedResource)
.Where(CompositeDefinitionHelper.ShouldFlatten)
.ToList();
flattenedMemberElements.AddRange(
processorContext.CurrentElement
.Elements(CompositeDefinitionHelper.EmbeddedObject)
.Where(CompositeDefinitionHelper.ShouldFlatten));
foreach (var flattenedMemberElt in flattenedMemberElements)
{
string flattenedMemberName = flattenedMemberElt.AttributeValue(CompositeDefinitionHelper.Name);
ResourceMemberBase resourceMemberToUse = null;
Resource flattenedResource = null;
bool memberIsReference = flattenedMemberElt.Name.LocalName == CompositeDefinitionHelper.ReferencedResource;
bool memberIsEmbeddedObject = flattenedMemberElt.Name.LocalName == CompositeDefinitionHelper.EmbeddedObject;
if (memberIsReference)
{
if (!processorContext.CurrentResourceClass.ReferenceByName.TryGetValue(
flattenedMemberName, out Reference resourceToUseAsReference))
{
// Look for a "descriptor" property
if (processorContext.CurrentResourceClass.PropertyByName.TryGetValue(
flattenedMemberName,
out ResourceProperty descriptorProperty))
{
resourceMemberToUse = descriptorProperty;
flattenedResource =
processorContext.CurrentResourceClass.ResourceModel.GetResourceByFullName(
descriptorProperty.DescriptorResource.Entity.FullName);
}
else
{
ApplyValidationMessage("resource reference", flattenedMemberName, currentContainingElementName);
continue;
}
}
else
{
resourceMemberToUse = resourceToUseAsReference;
flattenedResource =
processorContext.CurrentResourceClass.ResourceModel.GetResourceByFullName(
resourceToUseAsReference.ReferencedResource.Entity.FullName);
}
}
else if (memberIsEmbeddedObject)
{
if (!processorContext.CurrentResourceClass.EmbeddedObjectByName.TryGetValue(
flattenedMemberName, out EmbeddedObject resourceAsEmbeddedObject))
{
ApplyValidationMessage("embedded object", flattenedMemberName, currentContainingElementName);
continue;
}
resourceMemberToUse = resourceAsEmbeddedObject;
flattenedResource =
processorContext.CurrentResourceClass.ResourceModel.GetResourceByFullName(
resourceAsEmbeddedObject.Parent.Entity.FullName);
}
else
{
// Defensive programming, but also throw a helpful message in the event it does ever happen
throw new NotSupportedException(
$"Flattened elements of type '{flattenedMemberElt.Name.LocalName}' are not yet supported.");
}
var flattenedBuilderContext = _compositeBuilder.CreateFlattenedMemberContext(builderContext);
var flattenedProcessingContext = new CompositeDefinitionProcessorContext(
processorContext.CompositeDefinitionElement,
processorContext.ResourceModel,
flattenedMemberElt,
flattenedResource,
null,
null,
null,
0,
resourceMemberToUse);
var shouldContinueWithValidation = resourceMemberToUse == null && _performValidation;
if (flattenedResource.Entity.IsAggregateRoot)
{
// Provide opportunity to perform processing related to navigating into another resource (i.e. authorization)
if (!_compositeBuilder.TryIncludeResource(flattenedProcessingContext, flattenedBuilderContext))
{
continue;
}
}
if (shouldContinueWithValidation)
{
continue;
}
_compositeBuilder.ApplyFlattenedMember(resourceMemberToUse, flattenedBuilderContext);
// TODO: Consider refining what is passed into Resource model classes rather than XElements
var propertyElements = flattenedMemberElt
.Elements(CompositeDefinitionHelper.Property)
.ToList();
List <CompositePropertyProjection> flattenedPropertyProjections = new List <CompositePropertyProjection>();
if (memberIsReference)
{
flattenedPropertyProjections = GetPropertyProjections(
flattenedProcessingContext,
propertyElements);
}
else if (memberIsEmbeddedObject)
{
flattenedPropertyProjections = GetPropertyProjectionsForNonAggregateRoot(
processorContext,
(EmbeddedObject)resourceMemberToUse,
propertyElements,
currentContainingElementName);
}
_compositeBuilder.ProjectProperties(
flattenedPropertyProjections, flattenedBuilderContext, flattenedProcessingContext);
// Recursively process flattened resource properties
ProcessFlattenedMemberProperties(
flattenedProcessingContext,
flattenedBuilderContext);
}
}
