internal static Deserializer CreateDeserializer(System.Data.Services.RequestDescription description, IDataService dataService, bool update, UpdateTracker tracker)
{
string str;
Encoding encoding;
HttpProcessUtility.ReadContentType(dataService.OperationContext.Host.RequestContentType, out str, out encoding);
if (DataServiceActionProviderWrapper.IsServiceActionRequest(description))
{
return(new ParameterDeserializer(update, dataService, tracker, description));
}
if ((description.TargetKind == RequestTargetKind.OpenPropertyValue) || (description.TargetKind == RequestTargetKind.PrimitiveValue))
{
return(new RawValueDeserializer(update, dataService, tracker, description));
}
if (description.TargetKind == RequestTargetKind.MediaResource)
{
return(new MediaResourceDeserializer(update, dataService, tracker, description));
}
if (((description.TargetKind == RequestTargetKind.Primitive) || (description.TargetKind == RequestTargetKind.ComplexObject)) || ((description.TargetKind == RequestTargetKind.Collection) || (description.TargetKind == RequestTargetKind.OpenProperty)))
{
return(new PropertyDeserializer(update, dataService, tracker, description));
}
if (description.LinkUri)
{
return(new EntityReferenceLinkDeserializer(update, dataService, tracker, description));
}
if (description.TargetKind != RequestTargetKind.Resource)
{
throw new DataServiceException(0x19f, System.Data.Services.Strings.RequestUriProcessor_MethodNotAllowed);
}
return(new EntityDeserializer(update, dataService, tracker, description));
}
internal object HandlePutRequest()
{
object requestValue = null;
object entityResource = null;
ResourceSetWrapper entityContainer = null;
string str;
Encoding encoding;
HttpProcessUtility.ReadContentType(this.Service.OperationContext.Host.RequestContentType, out str, out encoding);
System.Data.Services.RequestDescription requestDescription = this.RequestDescription;
if (((requestDescription.TargetKind == RequestTargetKind.MediaResource) || (requestDescription.TargetKind == RequestTargetKind.OpenPropertyValue)) || (requestDescription.TargetKind == RequestTargetKind.PrimitiveValue))
{
requestValue = this.Deserialize(requestDescription.LastSegmentInfo);
}
else if (requestDescription.LinkUri)
{
Uri referencedUri = (Uri)this.Deserialize(null);
object targetResourceToBind = this.GetTargetResourceToBind(referencedUri, true);
entityResource = HandleBindOperation(requestDescription, targetResourceToBind, this.Service, this.Tracker);
entityContainer = requestDescription.LastSegmentInfo.TargetContainer;
}
else
{
requestValue = this.ReadEntity();
if (((requestValue == null) && requestDescription.LastSegmentInfo.HasKeyValues) && (requestDescription.TargetSource == RequestTargetSource.EntitySet))
{
throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.BadRequest_CannotSetTopLevelResourceToNull(requestDescription.ResultUri.AbsoluteUri));
}
}
if (!requestDescription.LinkUri && IsQueryRequired(requestDescription, requestValue))
{
object resourceToBeModified = GetResourceToModify(requestDescription, this.Service, false, out entityResource, out entityContainer, true);
this.Tracker.TrackAction(entityResource, entityContainer, UpdateOperations.Change);
ModifyResource(requestDescription, resourceToBeModified, requestValue, this.Service);
}
return(entityResource ?? requestValue);
}
internal static bool GetBoundaryAndEncodingFromMultipartMixedContentType(string contentType, out string boundary, out Encoding encoding)
{
boundary = null;
encoding = null;
string mime;
KeyValuePair <string, string>[] parameters = HttpProcessUtility.ReadContentType(contentType, out mime, out encoding);
if (String.Equals(XmlConstants.MimeMultiPartMixed, mime, StringComparison.OrdinalIgnoreCase))
{
if (null != parameters)
{
foreach (KeyValuePair <string, string> parameter in parameters)
{
if (String.Equals(parameter.Key, XmlConstants.HttpMultipartBoundary, StringComparison.OrdinalIgnoreCase))
{
if (boundary != null)
{
boundary = null;
break;
}
boundary = parameter.Value;
}
}
}
if (String.IsNullOrEmpty(boundary))
{
throw Error.BatchStreamMissingBoundary();
}
}
return(null != boundary);
}
/// <summary>
/// Read the link media type and validate for non open property types
/// </summary>
/// <param name="mediaType">media type as specified on the link element.</param>
/// <param name="property">property which the link represents.</param>
/// <returns>returns the type parameters specified in the media link.</returns>
private static string ValidateTypeParameterForNonOpenTypeProperties(string mediaType, ResourceProperty property)
{
string typeParameterValue = null;
if (!String.IsNullOrEmpty(mediaType))
{
string mime;
Encoding encoding;
KeyValuePair <string, string>[] contentTypeParameters = HttpProcessUtility.ReadContentType(mediaType, out mime, out encoding);
if (mime != XmlConstants.MimeApplicationAtom)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_MimeTypeMustBeApplicationAtom(mime, XmlConstants.MimeApplicationAtom));
}
// If the type parameter is specified, make sure its correct. We do the validation for known properties here
// and for open-properties, the validation is done if the link is expanded. Otherwise, there is no good way of
// doing the validation.
typeParameterValue = HttpProcessUtility.GetParameterValue(contentTypeParameters, XmlConstants.AtomTypeAttributeName);
if (!String.IsNullOrEmpty(typeParameterValue) && property != null)
{
if (property.Kind == ResourcePropertyKind.ResourceReference)
{
if (typeParameterValue != XmlConstants.AtomEntryElementName)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_InvalidTypeParameterSpecifiedInMimeType(typeParameterValue, XmlConstants.AtomEntryElementName));
}
}
else if (typeParameterValue != XmlConstants.AtomFeedElementName)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_InvalidTypeParameterSpecifiedInMimeType(typeParameterValue, XmlConstants.AtomFeedElementName));
}
}
}
return(typeParameterValue);
}
