/// <summary>
/// Handle the navigation properties as specified in the payload
/// </summary>
/// <param name="parentResourceSet">resource set where <paramref name="resource"/> belongs to</param>
/// <param name="parentResourceType">resource type declaring the navigation property.</param>
/// <param name="resource">instance of the resource declaring the navigation property.</param>
/// <param name="resourceProperty">resource property containing metadata about the navigation property.</param>
/// <param name="propertyValue">value of the navigation property.</param>
private void HandleNavigationProperty(ResourceSetWrapper parentResourceSet, ResourceType parentResourceType, object resource, ResourceProperty resourceProperty, object propertyValue)
{
Debug.Assert(parentResourceSet != null, "parentResourceSet != null");
Debug.Assert(parentResourceType != null, "parentResourceType != null");
Debug.Assert(resourceProperty != null && resourceProperty.TypeKind == ResourceTypeKind.EntityType, "its must be a nav property");
bool existingRelationship;
Deserializer.CheckForBindingInPutOperations(this.Service.OperationContext.Host.AstoriaHttpVerb);
ResourceSetWrapper propertySet = this.Service.Provider.GetContainer(parentResourceSet, parentResourceType, resourceProperty);
if (propertySet == null)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_InvalidPropertyNameSpecified(resourceProperty.Name, parentResourceType.FullName));
}
// FeatureVersion needs to be 2.0 if any of the property in the types contained in the resource set has KeepInContent false
this.RequestDescription.UpdateAndCheckEpmFeatureVersion(propertySet, this.Service);
if (resourceProperty.Kind == ResourcePropertyKind.ResourceReference)
{
SegmentInfo segmentInfo = CreateSegment(resourceProperty, resourceProperty.Name, propertySet, true /* singleResult */);
segmentInfo.TargetKind = RequestTargetKind.Resource;
// For navigation property, allow both inserts and binding in this case
propertyValue = this.CreateObject(propertyValue, segmentInfo, false /*topLevel*/, out existingRelationship);
if (!existingRelationship)
{
this.Updatable.SetReference(resource, resourceProperty.Name, propertyValue);
}
}
else if (resourceProperty.Kind == ResourcePropertyKind.ResourceSetReference)
{
if (propertyValue == null)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_CannotSetCollectionsToNull(resourceProperty.Name));
}
ArrayList resourceCollection = GetArrayList(propertyValue);
SegmentInfo segmentInfo = CreateSegment(resourceProperty, resourceProperty.Name, propertySet, true /* singleResult */);
foreach (object resourceObject in resourceCollection)
{
object resourceInstance = this.CreateObject(resourceObject, segmentInfo, false /*topLevel*/, out existingRelationship);
Debug.Assert(resourceInstance != null, "resourceInstance != null");
if (!existingRelationship)
{
this.Updatable.AddReferenceToCollection(resource, resourceProperty.Name, resourceInstance);
}
}
}
}
/// <summary>Reads the current object from the <paramref name="item"/>.</summary>
/// <param name="segmentInfo">segmentinfo containing information about the current element that is getting processes</param>
/// <param name="topLevel">true if the element currently pointed by the xml reader refers to a top level element</param>
/// <param name="item">Item to read from.</param>
/// <returns>returns the clr object with the data populated</returns>
private object CreateObject(SegmentInfo segmentInfo, bool topLevel, SyndicationItem item)
{
Debug.Assert(item != null, "item != null");
Debug.Assert(topLevel || !this.Update, "deep updates not supported");
this.RecurseEnter();
object result;
// update the object count everytime you encounter a new resource
this.CheckAndIncrementObjectCount();
// Process the type annotation.
ResourceType currentResourceType = this.GetResourceType(item, segmentInfo.TargetResourceType);
if (currentResourceType.ResourceTypeKind != ResourceTypeKind.EntityType)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_OnlyEntityTypesMustBeSpecifiedInEntryElement(currentResourceType.FullName));
}
// We have the actual type info from the payload. Update the request/response DSV if any property is FF mapped with KeepInContent=false.
this.UpdateAndCheckEpmRequestResponseDSV(currentResourceType, topLevel);
// Get a resource cookie from the provider.
ResourceSetWrapper container;
if (segmentInfo.TargetKind == RequestTargetKind.OpenProperty)
{
// Open navigation properties are not supported on OpenTypes.
throw DataServiceException.CreateBadRequestError(Strings.OpenNavigationPropertiesNotSupportedOnOpenTypes(segmentInfo.Identifier));
}
else
{
Debug.Assert(segmentInfo.TargetKind == RequestTargetKind.Resource, "segmentInfo.TargetKind == RequestTargetKind.Resource");
container = segmentInfo.TargetContainer;
}
DataServiceHostWrapper host = this.Service.OperationContext.Host;
if (this.Update)
{
Debug.Assert(currentResourceType.ResourceTypeKind == ResourceTypeKind.EntityType, "only expecting entity types");
// Only verify ETag if there is going to be some update applied (that's the idea)
// In reality:
// - for normal entities (V1 compatible) - don't check ETags if there is no content element. (Same as in V1)
// - for V2 stuff - check ETags always as we can't tell if there's going to be something modified or not
// with EPM properties can be anywhere in the payload and thus even without content there still can be updates
// with MLE the properties are not in the content element but in their own element
// It's hard to recognize if there's going to be update up front and so this below is an approximation
// which seems to be good enough. Note that if we add new ways of handling properties in the content
// the condition below might need to change.
bool verifyETag =
topLevel &&
(HasContent(item) || currentResourceType.HasEntityPropertyMappings || currentResourceType.IsMediaLinkEntry);
bool replaceResource = topLevel && host.AstoriaHttpVerb == AstoriaVerbs.PUT;
// if its a top level resource, then it cannot be null
result = this.GetObjectFromSegmentInfo(currentResourceType, segmentInfo, verifyETag, topLevel /*checkForNull*/, replaceResource);
if (this.Tracker != null)
{
this.Tracker.TrackAction(result, container, UpdateOperations.Change);
}
}
else
{
if (segmentInfo.TargetKind == RequestTargetKind.Resource)
{
DataServiceConfiguration.CheckResourceRights(segmentInfo.TargetContainer, EntitySetRights.WriteAppend);
}
result = this.Updatable.CreateResource(container.Name, currentResourceType.FullName);
if (this.Tracker != null)
{
this.Tracker.TrackAction(result, container, UpdateOperations.Add);
}
}
// Process the content in the entry.
EpmContentDeSerializer.EpmAppliedPropertyInfo propertiesApplied = new EpmContentDeSerializer.EpmAppliedPropertyInfo();
this.ApplyProperties(item, currentResourceType, propertiesApplied, result);
// Perform application of epm properties here
if (currentResourceType.HasEntityPropertyMappings)
{
new EpmContentDeSerializer(currentResourceType, result).DeSerialize(
item,
new EpmContentDeSerializer.EpmContentDeserializerState {
IsUpdateOperation = this.Update, Updatable = this.Updatable, Service = this.Service, PropertiesApplied = propertiesApplied
});
}
// Process the links in the entry.
foreach (SyndicationLink link in item.Links)
{
string navigationPropertyName = UriUtil.GetNameFromAtomLinkRelationAttribute(link.RelationshipType);
if (null == navigationPropertyName)
{
continue;
}
Deserializer.CheckForBindingInPutOperations(host.AstoriaHttpVerb);
Debug.Assert(segmentInfo.TargetContainer != null, "segmentInfo.TargetContainer != null");
this.ApplyLink(link, segmentInfo.TargetContainer, currentResourceType, result, navigationPropertyName);
}
this.RecurseLeave();
return(result);
}