public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
string asyncToken = this.QueryContext.AsyncToken;
AsyncTask asyncTask = AsyncTask.GetTask(asyncToken);
if (asyncTask == null)
{
// token is invalid or expired.
throw Utility.BuildException(HttpStatusCode.NotFound);
}
else
{
if (!asyncTask.Ready)
{
ResponseWriter.WriteAsyncPendingResponse(responseMessage, asyncToken);
}
else
{
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ContentType, "application/http");
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ContentTransferEncoding, ServiceConstants.HttpHeaderValues.Binary);
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
var asyncWriter = messageWriter.CreateODataAsynchronousWriter();
var innerResponse = asyncWriter.CreateResponseMessage();
asyncTask.Execute(innerResponse);
}
}
}
}
public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
string asyncToken = this.QueryContext.AsyncToken;
AsyncTask asyncTask = AsyncTask.GetTask(asyncToken);
if (asyncTask == null)
{
// token is invalid or expired.
throw Utility.BuildException(HttpStatusCode.NotFound);
}
else
{
if (!asyncTask.Ready)
{
ResponseWriter.WriteAsyncPendingResponse(responseMessage, asyncToken);
}
else
{
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ContentType, "application/http");
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ContentTransferEncoding, ServiceConstants.HttpHeaderValues.Binary);
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
var asyncWriter = messageWriter.CreateODataAsynchronousWriter();
var innerResponse = asyncWriter.CreateResponseMessage();
asyncTask.Execute(innerResponse);
}
}
}
}
internal ResponseBodyWriter(bool hasMoved, IDataService service, IEnumerator queryResults, RequestDescription requestDescription, IODataResponseMessage responseMessage, ODataPayloadKind payloadKind)
{
this.hasMoved = hasMoved;
this.service = service;
this.queryResults = queryResults;
this.requestDescription = requestDescription;
this.responseMessage = responseMessage;
this.payloadKind = payloadKind;
this.encoding = HttpProcessUtility.EncodingFromAcceptCharset(this.service.OperationContext.Host.RequestAcceptCharSet);
if ((((payloadKind == ODataPayloadKind.Entry) || (payloadKind == ODataPayloadKind.Feed)) || ((payloadKind == ODataPayloadKind.Property) || (payloadKind == ODataPayloadKind.Collection))) || (((payloadKind == ODataPayloadKind.EntityReferenceLink) || (payloadKind == ODataPayloadKind.EntityReferenceLinks)) || (((payloadKind == ODataPayloadKind.Error) || (payloadKind == ODataPayloadKind.ServiceDocument)) || (payloadKind == ODataPayloadKind.Parameter))))
{
DataServiceHostWrapper host = service.OperationContext.Host;
if (WebUtil.GetEffectiveMaxResponseVersion(service.Configuration.DataServiceBehavior.MaxProtocolVersion, host.RequestMaxVersion) > RequestDescription.Version2Dot0)
{
bool isEntityOrFeed = (payloadKind == ODataPayloadKind.Entry) || (payloadKind == ODataPayloadKind.Feed);
if (WebUtil.ResponseMediaTypeWouldBeJsonLight(host.RequestAccept, isEntityOrFeed))
{
requestDescription.VerifyAndRaiseResponseVersion(RequestDescription.Version3Dot0, service);
host.ResponseVersion = RequestDescription.Version3Dot0.ToString() + ";";
}
}
}
if (this.requestDescription.TargetKind == RequestTargetKind.MediaResource)
{
this.mediaResourceStream = service.StreamProvider.GetReadStream(this.queryResults.Current, RequestDescription.GetStreamProperty(this.requestDescription), this.service.OperationContext);
}
else if (payloadKind != ODataPayloadKind.BinaryValue)
{
string requestAcceptCharSet = this.service.OperationContext.Host.RequestAcceptCharSet;
if (string.IsNullOrEmpty(requestAcceptCharSet) || (requestAcceptCharSet == "*"))
{
requestAcceptCharSet = "UTF-8";
}
if ((payloadKind == ODataPayloadKind.Value) && !string.IsNullOrEmpty(this.requestDescription.MimeType))
{
this.messageWriter = CreateMessageWriter(this.AbsoluteServiceUri, this.service, this.requestDescription.ActualResponseVersion, responseMessage, ODataFormat.RawValue);
}
else
{
this.messageWriter = CreateMessageWriter(this.AbsoluteServiceUri, this.service, this.requestDescription.ActualResponseVersion, responseMessage, this.service.OperationContext.Host.RequestAccept, requestAcceptCharSet);
}
try
{
this.contentFormat = ODataUtils.SetHeadersForPayload(this.messageWriter, payloadKind);
if ((payloadKind == ODataPayloadKind.Value) && !string.IsNullOrEmpty(this.requestDescription.MimeType))
{
responseMessage.SetHeader("Content-Type", this.requestDescription.MimeType);
}
}
catch (ODataContentTypeException exception)
{
throw new DataServiceException(0x19f, null, System.Data.Services.Strings.DataServiceException_UnsupportedMediaType, null, exception);
}
string headerValue = this.requestDescription.ResponseVersion.ToString() + ";";
responseMessage.SetHeader("DataServiceVersion", headerValue);
}
}
internal ResponseBodyWriter(bool hasMoved, IDataService service, IEnumerator queryResults, RequestDescription requestDescription, IODataResponseMessage responseMessage, ODataPayloadKind payloadKind)
{
this.hasMoved = hasMoved;
this.service = service;
this.queryResults = queryResults;
this.requestDescription = requestDescription;
this.responseMessage = responseMessage;
this.payloadKind = payloadKind;
this.encoding = HttpProcessUtility.EncodingFromAcceptCharset(this.service.OperationContext.Host.RequestAcceptCharSet);
if ((((payloadKind == ODataPayloadKind.Entry) || (payloadKind == ODataPayloadKind.Feed)) || ((payloadKind == ODataPayloadKind.Property) || (payloadKind == ODataPayloadKind.Collection))) || (((payloadKind == ODataPayloadKind.EntityReferenceLink) || (payloadKind == ODataPayloadKind.EntityReferenceLinks)) || (((payloadKind == ODataPayloadKind.Error) || (payloadKind == ODataPayloadKind.ServiceDocument)) || (payloadKind == ODataPayloadKind.Parameter))))
{
DataServiceHostWrapper host = service.OperationContext.Host;
if (WebUtil.GetEffectiveMaxResponseVersion(service.Configuration.DataServiceBehavior.MaxProtocolVersion, host.RequestMaxVersion) > RequestDescription.Version2Dot0)
{
bool isEntityOrFeed = (payloadKind == ODataPayloadKind.Entry) || (payloadKind == ODataPayloadKind.Feed);
if (WebUtil.ResponseMediaTypeWouldBeJsonLight(host.RequestAccept, isEntityOrFeed))
{
requestDescription.VerifyAndRaiseResponseVersion(RequestDescription.Version3Dot0, service);
host.ResponseVersion = RequestDescription.Version3Dot0.ToString() + ";";
}
}
}
if (this.requestDescription.TargetKind == RequestTargetKind.MediaResource)
{
this.mediaResourceStream = service.StreamProvider.GetReadStream(this.queryResults.Current, RequestDescription.GetStreamProperty(this.requestDescription), this.service.OperationContext);
}
else if (payloadKind != ODataPayloadKind.BinaryValue)
{
string requestAcceptCharSet = this.service.OperationContext.Host.RequestAcceptCharSet;
if (string.IsNullOrEmpty(requestAcceptCharSet) || (requestAcceptCharSet == "*"))
{
requestAcceptCharSet = "UTF-8";
}
if ((payloadKind == ODataPayloadKind.Value) && !string.IsNullOrEmpty(this.requestDescription.MimeType))
{
this.messageWriter = CreateMessageWriter(this.AbsoluteServiceUri, this.service, this.requestDescription.ActualResponseVersion, responseMessage, ODataFormat.RawValue);
}
else
{
this.messageWriter = CreateMessageWriter(this.AbsoluteServiceUri, this.service, this.requestDescription.ActualResponseVersion, responseMessage, this.service.OperationContext.Host.RequestAccept, requestAcceptCharSet);
}
try
{
this.contentFormat = ODataUtils.SetHeadersForPayload(this.messageWriter, payloadKind);
if ((payloadKind == ODataPayloadKind.Value) && !string.IsNullOrEmpty(this.requestDescription.MimeType))
{
responseMessage.SetHeader("Content-Type", this.requestDescription.MimeType);
}
}
catch (ODataContentTypeException exception)
{
throw new DataServiceException(0x19f, null, System.Data.Services.Strings.DataServiceException_UnsupportedMediaType, null, exception);
}
string headerValue = this.requestDescription.ResponseVersion.ToString() + ";";
responseMessage.SetHeader("DataServiceVersion", headerValue);
}
}
public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
if (this.TryDispatch(requestMessage, responseMessage))
{
return;
}
if (this.QueryContext.Target.TypeKind != EdmTypeKind.Collection)
{
throw Utility.BuildException(HttpStatusCode.BadRequest, "The new resource can only be created under collection resource.", null);
}
if (this.QueryContext.Target.IsReference)
{
this.ProcessCreateLink(requestMessage, responseMessage);
return;
}
try
{
var targetEntitySet = (IEdmEntitySetBase)this.QueryContext.Target.NavigationSource;
// TODO: [lianw] Try to remove "targetEntitySet" later.
var queryResults = this.QueryContext.ResolveQuery(this.DataSource);
if (!IsAllowInsert(targetEntitySet as IEdmEntitySet))
{
throw new ODataServiceException(HttpStatusCode.BadRequest, "The insert request is not allowed.", null);
}
var bodyObject = ProcessPostBody(requestMessage, targetEntitySet, queryResults);
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
this.DataSource.UpdateProvider.SaveChanges();
// 11.4.2 Create an Entity
// Upon successful completion the service MUST respond with either 201 Created, or 204 No Content if the request included a return Prefer header with a value of return=minimal.
responseMessage.SetStatusCode(HttpStatusCode.Created);
responseMessage.SetHeader(ServiceConstants.HttpHeaders.Location, Utility.BuildLocationUri(this.QueryContext, bodyObject).OriginalString);
var currentETag = Utility.GetETagValue(bodyObject);
// if the current entity has ETag field
if (currentETag != null)
{
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
ResponseWriter.WriteEntry(messageWriter.CreateODataResourceWriter(targetEntitySet), bodyObject, targetEntitySet, ODataVersion.V4, null);
}
}
catch
{
this.DataSource.UpdateProvider.ClearChanges();
throw;
}
}
public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
if (this.TryDispatch(requestMessage, responseMessage))
{
return;
}
if (this.QueryContext.Target.TypeKind != EdmTypeKind.Collection)
{
throw Utility.BuildException(HttpStatusCode.BadRequest, "The new resource can only be created under collection resource.", null);
}
if (this.QueryContext.Target.IsReference)
{
this.ProcessCreateLink(requestMessage, responseMessage);
return;
}
try
{
var targetEntitySet = (IEdmEntitySetBase)this.QueryContext.Target.NavigationSource;
// TODO: [lianw] Try to remove "targetEntitySet" later.
var queryResults = this.QueryContext.ResolveQuery(this.DataSource);
if (!IsAllowInsert(targetEntitySet as IEdmEntitySet))
{
throw new ODataServiceException(HttpStatusCode.BadRequest, "The insert request is not allowed.", null);
}
var bodyObject = ProcessPostBody(requestMessage, targetEntitySet, queryResults);
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
this.DataSource.UpdateProvider.SaveChanges();
// 11.4.2 Create an Entity
// Upon successful completion the service MUST respond with either 201 Created, or 204 No Content if the request included a return Prefer header with a value of return=minimal.
responseMessage.SetStatusCode(HttpStatusCode.Created);
responseMessage.SetHeader(ServiceConstants.HttpHeaders.Location, Utility.BuildLocationUri(this.QueryContext, bodyObject).OriginalString);
var currentETag = Utility.GetETagValue(bodyObject);
// if the current entity has ETag field
if (currentETag != null)
{
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
ResponseWriter.WriteEntry(messageWriter.CreateODataEntryWriter(targetEntitySet), bodyObject, targetEntitySet, ODataVersion.V4, null);
}
}
catch
{
this.DataSource.UpdateProvider.ClearChanges();
throw;
}
}
private ODataAsynchronousReader CreateAsyncReader(string payload)
{
responseStream = new MemoryStream(Encoding.Default.GetBytes(payload));
responseMessage = new InMemoryMessage {
Stream = responseStream
};
responseMessage.SetHeader("Content-Type", "application/http");
responseMessage.SetHeader("Content-Transfer-Encoding", "binary");
this.messageReader = new ODataMessageReader(responseMessage, new ODataMessageReaderSettings(), userModel);
return(this.messageReader.CreateODataAsynchronousReader());
}
public static void AddPreferenceApplied(this IODataResponseMessage message, string appliedPref)
{
if (!string.IsNullOrEmpty(appliedPref))
{
if (string.IsNullOrEmpty(message.GetHeader(ServiceConstants.HttpHeaders.PreferenceApplied)))
{
message.SetHeader(ServiceConstants.HttpHeaders.PreferenceApplied, appliedPref);
}
else
{
message.SetHeader(ServiceConstants.HttpHeaders.PreferenceApplied,
string.Format("{0};{1}", message.GetHeader(ServiceConstants.HttpHeaders.PreferenceApplied), appliedPref));
}
}
}
/// <summary>
/// Write empty response and set the HttpStatusCode to 202 Accepted
/// </summary>
/// <param name="responseMessage"></param>
/// <param name="asyncToken"></param>
public static void WriteAsyncPendingResponse(IODataResponseMessage responseMessage, string asyncToken)
{
responseMessage.SetStatusCode(HttpStatusCode.Accepted);
responseMessage.SetHeader(ServiceConstants.HttpHeaders.DataServiceVersion, "4.0");
Uri location = new Uri(ServiceConstants.ServiceBaseUri, string.Format("{0}?{1}={2}", ServiceConstants.ServicePath_Async, ServiceConstants.QueryOption_AsyncToken, asyncToken));
responseMessage.SetHeader(ServiceConstants.HttpHeaders.Location, location.OriginalString);
if (!(responseMessage is ODataBatchOperationResponseMessage))
{
using (responseMessage.GetStream())
{
}
}
}
public static void InitClass(TestContext testContext)
{
RequestWithApplicationJson = new ODataRequestMessageSimulator();
RequestWithApplicationJson.SetHeader(XmlConstants.HttpContentType, "aPPlicaTion/jSoN");
ResponseWithApplicationJson = new ODataResponseMessageSimulator();
ResponseWithApplicationJson.SetHeader(XmlConstants.HttpContentType, "aPPlicaTion/jSoN");
}
/// <summary>
/// Applies headers in the dictionary to a response message.
/// </summary>
/// <param name="headers">The dictionary with the headers to apply.</param>
/// <param name="responseMessage">The request message to apply the headers to.</param>
private static void ApplyHeadersToResponse(HeaderCollection headers, IODataResponseMessage responseMessage)
{
// NetCF bug with how the enumerators for dictionaries work.
foreach (KeyValuePair <string, string> header in headers.AsEnumerable().ToList())
{
responseMessage.SetHeader(header.Key, header.Value);
}
}
public static void InitClass(TestContext testContext)
{
RequestWithApplicationJson = new ODataRequestMessageSimulator();
RequestWithApplicationJson.SetHeader(XmlConstants.HttpContentType, "aPPlicaTion/jSoN");
ResponseWithApplicationJson = new ODataResponseMessageSimulator();
ResponseWithApplicationJson.SetHeader(XmlConstants.HttpContentType, "aPPlicaTion/jSoN");
}
public DataServiceClientFormatTests()
{
RequestWithApplicationJson = new ODataRequestMessageSimulator();
RequestWithApplicationJson.SetHeader(XmlConstants.HttpContentType, "aPPlicaTion/jSoN");
ResponseWithApplicationJson = new ODataResponseMessageSimulator();
ResponseWithApplicationJson.SetHeader(XmlConstants.HttpContentType, "aPPlicaTion/jSoN");
this.v3Context = new DataServiceContext(new Uri("http://temp.org/"), ODataProtocolVersion.V4).ReConfigureForNetworkLoadingTests();
this.v3TestSubject = this.v3Context.Format;
}
/// <summary>
/// Write empty response and set the HttpStatusCode to 204 NoContent
/// </summary>
/// <param name="responseMessage"></param>
public static void WriteEmptyResponse(IODataResponseMessage responseMessage, HttpStatusCode statusCode = HttpStatusCode.NoContent)
{
responseMessage.SetStatusCode(statusCode);
responseMessage.SetHeader("OData-Version", "4.0");
if (!(responseMessage is ODataBatchOperationResponseMessage))
{
using (responseMessage.GetStream())
{
}
}
}
/// <summary>Handles an exception when processing a batch response.</summary>
/// <param name='service'>Data service doing the processing.</param>
/// <param name="requestMessage">requestMessage holding information about the request that caused an error</param>
/// <param name="responseMessage">responseMessage to which we need to write the exception message</param>
/// <param name='exception'>Exception thrown.</param>
/// <param name='batchWriter'>Output writer for the batch.</param>
/// <param name="responseStream">Underlying response stream.</param>
/// <param name="defaultResponseVersion">The data service version to use for response, if it cannot be computed from the requestMessage.</param>
internal static void HandleBatchOperationError(IDataService service, AstoriaRequestMessage requestMessage, IODataResponseMessage responseMessage, Exception exception, ODataBatchWriter batchWriter, Stream responseStream, Version defaultResponseVersion)
{
Debug.Assert(service != null, "service != null");
Debug.Assert(exception != null, "exception != null");
Debug.Assert(batchWriter != null, "batchWriter != null");
Debug.Assert(service.Configuration != null, "service.Configuration != null");
Debug.Assert(CommonUtil.IsCatchableExceptionType(exception), "CommonUtil.IsCatchableExceptionType(exception)");
ErrorHandler handler = CreateHandler(service, requestMessage, exception, defaultResponseVersion);
service.InternalHandleException(handler.exceptionArgs);
if (requestMessage != null && responseMessage != null)
{
responseMessage.SetHeader(XmlConstants.HttpODataVersion, handler.responseVersion.ToString(2) + ";");
requestMessage.ProcessException(handler.exceptionArgs);
// if ProcessBenignException returns anything, we can safely not write to the stream.
if (ProcessBenignException(exception, service) != null)
{
return;
}
}
if (requestMessage != null)
{
responseMessage = requestMessage.BatchServiceHost.GetOperationResponseMessage();
WebUtil.SetResponseHeadersForBatchRequests(responseMessage, requestMessage.BatchServiceHost);
}
else
{
responseMessage = batchWriter.CreateOperationResponseMessage(null);
responseMessage.StatusCode = handler.exceptionArgs.ResponseStatusCode;
}
MessageWriterBuilder messageWriterBuilder = MessageWriterBuilder.ForError(
null,
service,
handler.responseVersion,
responseMessage,
handler.contentType,
null /*acceptCharsetHeaderValue*/);
using (ODataMessageWriter messageWriter = messageWriterBuilder.CreateWriter())
{
ODataError error = handler.exceptionArgs.CreateODataError();
WriteErrorWithFallbackForXml(messageWriter, handler.encoding, responseStream, handler.exceptionArgs, error, messageWriterBuilder);
}
}
private void ProcessCreate(Stream requestStream, IODataResponseMessage responseMessage)
{
try
{
// handle insert annotation
if (!this.IsAllowInsert(this.QueryContext.Target.NavigationSource as IEdmEntitySet))
{
throw new ODataServiceException(HttpStatusCode.BadRequest, "The insert request is not allowed.", null);
}
// handle content type
var contentType = this.HandleContentType((IEdmEntityType)this.QueryContext.Target.ElementType);
// handle entity
var entities = this.QueryContext.ResolveQuery(this.DataSource);
var entity = this.DataSource.UpdateProvider.Create(this.QueryContext.Target.ElementType.FullTypeName(), entities);
this.DataSource.StreamProvider.CreateStream(entity, requestStream, contentType);
this.DataSource.UpdateProvider.SaveChanges();
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
responseMessage.SetHeader(ServiceConstants.HttpHeaders.Location, Utility.BuildLocationUri(this.QueryContext, entity).OriginalString);
if (this.PreferenceContext.Return == ServiceConstants.PreferenceValue_Return_Minimal)
{
responseMessage.SetStatusCode(HttpStatusCode.NoContent);
}
else
{
responseMessage.SetStatusCode(HttpStatusCode.Created);
var edmEntitySet = (IEdmEntitySetBase)this.QueryContext.Target.NavigationSource;
ResponseWriter.WriteEntry(messageWriter.CreateODataResourceWriter(edmEntitySet), entity, edmEntitySet, ODataVersion.V4, null);
}
}
}
catch
{
this.DataSource.UpdateProvider.ClearChanges();
throw;
}
}
private void ProcessUpdateRequestBody(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage, object targetObject, bool isUpsert)
{
if (this.QueryContext.Target.NavigationSource != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Entity)
{
using (var messageReader = new ODataMessageReader(requestMessage, this.GetReaderSettings(), this.DataSource.Model))
{
var entryReader = messageReader.CreateODataEntryReader(this.QueryContext.Target.NavigationSource, (IEdmEntityType)this.QueryContext.Target.Type);
while (entryReader.Read())
{
switch (entryReader.State)
{
case ODataReaderState.EntryEnd:
var entry = (ODataEntry)entryReader.Item;
foreach (var property in entry.Properties)
{
if (Utility.IsETagProperty(targetObject, property.Name)) continue;
// the property might be an open property, so test null first
var propertyInfo = targetObject.GetType().GetProperty(property.Name);
if (propertyInfo != null)
{
if (!isUpsert && Utility.IsReadOnly(propertyInfo)) continue;
}
this.DataSource.UpdateProvider.Update(targetObject, property.Name, property.Value);
}
break;
}
}
}
}
else if (this.QueryContext.Target.Property != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Complex)
{
using (var messageReader = new ODataMessageReader(requestMessage, this.GetReaderSettings(), this.DataSource.Model))
{
var property = messageReader.ReadProperty(this.QueryContext.Target.Property);
ODataComplexValue complexValue = property.Value as ODataComplexValue;
foreach (var p in complexValue.Properties)
{
if (Utility.IsETagProperty(targetObject, property.Name)) continue;
this.DataSource.UpdateProvider.Update(targetObject, p.Name, p.Value);
}
}
}
else
{
throw Utility.BuildException(
HttpStatusCode.NotImplemented,
string.Format("PATCH/PUT for '{0}' type is not supported.", this.QueryContext.Target.TypeKind),
null);
}
var currentETag = Utility.GetETagValue(targetObject);
// if the current entity has ETag field
if (currentETag != null)
{
if (!isUpsert)
{
this.DataSource.UpdateProvider.UpdateETagValue(targetObject);
}
this.DataSource.UpdateProvider.SaveChanges();
currentETag = Utility.GetETagValue(targetObject);
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
else
{
this.DataSource.UpdateProvider.SaveChanges();
}
ResponseWriter.WriteEmptyResponse(responseMessage);
}
private void ProcessCreate(Stream requestStream, IODataResponseMessage responseMessage)
{
try
{
// handle insert annotation
if (!this.IsAllowInsert(this.QueryContext.Target.NavigationSource as IEdmEntitySet))
{
throw new ODataServiceException(HttpStatusCode.BadRequest, "The insert request is not allowed.", null);
}
// handle content type
var contentType = this.HandleContentType((IEdmEntityType)this.QueryContext.Target.ElementType);
// handle entity
var entities = this.QueryContext.ResolveQuery(this.DataSource);
var entity = this.DataSource.UpdateProvider.Create(this.QueryContext.Target.ElementType.FullTypeName(), entities);
this.DataSource.StreamProvider.CreateStream(entity, requestStream, contentType);
this.DataSource.UpdateProvider.SaveChanges();
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
responseMessage.SetHeader(ServiceConstants.HttpHeaders.Location, Utility.BuildLocationUri(this.QueryContext, entity).OriginalString);
if (this.PreferenceContext.Return == ServiceConstants.PreferenceValue_Return_Minimal)
{
responseMessage.SetStatusCode(HttpStatusCode.NoContent);
}
else
{
responseMessage.SetStatusCode(HttpStatusCode.Created);
var edmEntitySet = (IEdmEntitySetBase)this.QueryContext.Target.NavigationSource;
ResponseWriter.WriteEntry(messageWriter.CreateODataEntryWriter(edmEntitySet), entity, edmEntitySet, ODataVersion.V4, null);
}
}
}
catch
{
this.DataSource.UpdateProvider.ClearChanges();
throw;
}
}
private void ProcessUpdateRequestBody(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage, object targetObject, bool isUpsert)
{
if ((this.QueryContext.Target.NavigationSource != null &&
(this.QueryContext.Target.TypeKind == EdmTypeKind.Entity || this.QueryContext.Target.TypeKind == EdmTypeKind.Complex)) ||
(this.QueryContext.Target.Property != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Complex))
{
using (var messageReader = new ODataMessageReader(requestMessage, this.GetReaderSettings()))
{
var entryReader = messageReader.CreateODataResourceReader(this.QueryContext.Target.NavigationSource, (IEdmStructuredType)this.QueryContext.Target.Type);
// Need to handle complex property or collection of complex property
var odataItemStack = new Stack <ODataItem>();
var entityStack = new Stack <IEdmNavigationSource>();
var parentInstances = new Stack <object>();
var currentTargetEntitySet = this.QueryContext.Target.NavigationSource;
int levelOfUndeclaredProperty = 0;
while (entryReader.Read())
{
switch (entryReader.State)
{
case ODataReaderState.ResourceStart:
{
if (levelOfUndeclaredProperty > 0)
{
break;
}
var entry = (ODataResource)entryReader.Item;
if (entry == null)
{
break;
}
odataItemStack.Push(entryReader.Item);
entityStack.Push(currentTargetEntitySet);
if (parentInstances.Count == 0)
{
parentInstances.Push(targetObject);
}
else
{
var parent2 = parentInstances.Peek();
if (parent2 == null)
{
// Here is for collection, we need to create a brand new instance.
var valueType = EdmClrTypeUtils.GetInstanceType(entry.TypeName);
parentInstances.Push(Utility.QuickCreateInstance(valueType));
}
else
{
parentInstances.Push(parent2);
}
}
break;
}
case ODataReaderState.ResourceEnd:
{
if (levelOfUndeclaredProperty > 0)
{
break;
}
var entry = (ODataResource)entryReader.Item;
if (entry == null)
{
break;
}
object newInstance = parentInstances.Pop();
currentTargetEntitySet = entityStack.Pop();
foreach (var property in entry.Properties)
{
if (Utility.IsETagProperty(targetObject, property.Name))
{
continue;
}
// the property might be an open property, so test null first
var propertyInfo = newInstance.GetType().GetProperty(property.Name);
if (propertyInfo != null)
{
if (!isUpsert && Utility.IsReadOnly(propertyInfo))
{
continue;
}
}
this.DataSource.UpdateProvider.Update(newInstance, property.Name, property.Value);
}
var boundNavPropAnnotation = odataItemStack.Pop().GetAnnotation <BoundNavigationPropertyAnnotation>();
if (boundNavPropAnnotation != null)
{
foreach (var boundProperty in boundNavPropAnnotation.BoundProperties)
{
var isCollection = boundProperty.Item1.IsCollection == true;
var propertyValue = isCollection ? boundProperty.Item2 : ((IEnumerable <object>)boundProperty.Item2).Single();
this.DataSource.UpdateProvider.Update(newInstance, boundProperty.Item1.Name, propertyValue);
}
}
var parentItem = odataItemStack.Count > 0 ? odataItemStack.Peek() : null;
if (parentItem != null)
{
// This new entry belongs to a navigation property and/or feed -
// propagate it up the tree for further processing.
AddChildInstanceAnnotation(parentItem, newInstance);
}
}
break;
case ODataReaderState.ResourceSetStart:
if (levelOfUndeclaredProperty > 0)
{
break;
}
odataItemStack.Push(entryReader.Item);
//"null" here indicate that we need to create a new instance for collection to replace the old one.
parentInstances.Push(null);
break;
case ODataReaderState.ResourceSetEnd:
{
if (levelOfUndeclaredProperty > 0)
{
break;
}
parentInstances.Pop();
var childAnnotation = odataItemStack.Pop().GetAnnotation <ChildInstanceAnnotation>();
var parentNavLink = odataItemStack.Count > 0 ? odataItemStack.Peek() as ODataNestedResourceInfo : null;
if (parentNavLink != null)
{
// This feed belongs to a navigation property or complex property or a complex collection property.
// propagate it up the tree for further processing.
AddChildInstanceAnnotations(parentNavLink, childAnnotation == null ? new object[0] : (childAnnotation.ChildInstances ?? new object[0]));
}
}
break;
case ODataReaderState.NestedResourceInfoStart:
{
object parent = parentInstances.Peek();
var nestedResourceInfo = (ODataNestedResourceInfo)entryReader.Item;
var property = parent.GetType().GetProperty(nestedResourceInfo.Name);
if (property == null || levelOfUndeclaredProperty > 0)
{
levelOfUndeclaredProperty++;
}
// skip undeclared property
if (levelOfUndeclaredProperty > 0)
{
break;
}
odataItemStack.Push(entryReader.Item);
var propertyInstance = property.GetValue(parent);
parentInstances.Push(propertyInstance);
IEdmNavigationProperty navigationProperty = currentTargetEntitySet == null ? null : currentTargetEntitySet.EntityType().FindProperty(nestedResourceInfo.Name) as IEdmNavigationProperty;
// Current model implementation doesn't expose associations otherwise this would be much cleaner.
if (navigationProperty != null)
{
currentTargetEntitySet = this.DataSource.Model.EntityContainer.EntitySets().Single(s => s.EntityType() == navigationProperty.Type.Definition);
}
else
{
currentTargetEntitySet = null;
}
entityStack.Push(currentTargetEntitySet);
break;
}
case ODataReaderState.NestedResourceInfoEnd:
{
// check: skip or not
int theLevelOfUndeclaredProperty = levelOfUndeclaredProperty;
if (levelOfUndeclaredProperty > 0)
{
levelOfUndeclaredProperty--;
}
// skip undeclared property
if (theLevelOfUndeclaredProperty > 0)
{
break;
}
var navigationLink = (ODataNestedResourceInfo)entryReader.Item;
parentInstances.Pop();
var childAnnotation = odataItemStack.Pop().GetAnnotation <ChildInstanceAnnotation>();
if (childAnnotation != null)
{
// Propagate the bound resources to the parent resource.
AddBoundNavigationPropertyAnnotation(odataItemStack.Peek(), navigationLink, childAnnotation == null ? new object[0] : childAnnotation.ChildInstances);
}
entityStack.Pop();
currentTargetEntitySet = entityStack.Peek();
break;
}
}
}
}
}
else
{
throw Utility.BuildException(
HttpStatusCode.NotImplemented,
string.Format("PATCH/PUT for '{0}' type is not supported.", this.QueryContext.Target.TypeKind),
null);
}
var currentETag = Utility.GetETagValue(targetObject);
// if the current entity has ETag field
if (currentETag != null)
{
if (!isUpsert)
{
this.DataSource.UpdateProvider.UpdateETagValue(targetObject);
}
this.DataSource.UpdateProvider.SaveChanges();
currentETag = Utility.GetETagValue(targetObject);
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
else
{
this.DataSource.UpdateProvider.SaveChanges();
}
ResponseWriter.WriteEmptyResponse(responseMessage);
}
public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
object result;
if (this.HttpMethod == HttpMethod.GET)
{
// we cannot invoke same action request multiple times, so only Functions are allowed to do the server-driven paging
this.QueryContext.InitializeServerDrivenPaging(this.PreferenceContext);
result = this.ProcessFunction();
if (this.PreferenceContext.MaxPageSize.HasValue)
{
responseMessage.AddPreferenceApplied(string.Format("{0}={1}", ServiceConstants.Preference_MaxPageSize, this.QueryContext.appliedPageSize.Value));
}
}
else
{
// TODO: currently ETag feature does not support action operation
result = this.ProcessAction(requestMessage);
}
if (result == null)
{
// Protocol 9.1.4 Response Code 204 No Content
// A request returns 204 No Content if the requested resource has the null value,
// or if the service applies a return=minimal preference. In this case, the response body MUST be empty.
ResponseWriter.WriteEmptyResponse(responseMessage);
return;
}
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
if (this.QueryContext.Target.TypeKind == EdmTypeKind.None ||
this.QueryContext.Target.TypeKind == EdmTypeKind.EntityReference ||
this.QueryContext.Target.ElementTypeKind == EdmTypeKind.EntityReference)
{
throw Utility.BuildException(HttpStatusCode.NotImplemented, "Unsupported return type in operation.", null);
}
else if (this.QueryContext.Target.TypeKind == EdmTypeKind.Entity || this.QueryContext.Target.ElementTypeKind == EdmTypeKind.Entity ||
this.QueryContext.Target.TypeKind == EdmTypeKind.Complex || this.QueryContext.Target.ElementTypeKind == EdmTypeKind.Complex)
{
ODataWriter resultWriter;
IEdmNavigationSource entitySource = this.QueryContext.OperationResultSource ?? this.QueryContext.Target.NavigationSource;
if (this.QueryContext.Target.TypeKind == EdmTypeKind.Collection)
{
IEdmEntitySetBase entitySet = (IEdmEntitySetBase)entitySource;
resultWriter = messageWriter.CreateODataResourceSetWriter(entitySet, (IEdmStructuredType)this.QueryContext.Target.ElementType);
ResponseWriter.WriteFeed(resultWriter, (IEdmStructuredType)this.QueryContext.Target.ElementType, result as IEnumerable, entitySet, ODataVersion.V4, this.QueryContext.QuerySelectExpandClause, this.QueryContext.TotalCount, null, this.QueryContext.NextLink, this.RequestHeaders);
}
else
{
if (this.HttpMethod == HttpMethod.GET)
{
var currentETag = Utility.GetETagValue(result);
// if the current entity has ETag field
if (currentETag != null)
{
string requestETag;
if (Utility.TryGetIfNoneMatch(this.RequestHeaders, out requestETag) && (requestETag == ServiceConstants.ETagValueAsterisk || requestETag == currentETag))
{
ResponseWriter.WriteEmptyResponse(responseMessage, HttpStatusCode.NotModified);
return;
}
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
}
resultWriter = messageWriter.CreateODataResourceWriter(entitySource, (IEdmStructuredType)this.QueryContext.Target.Type);
ResponseWriter.WriteEntry(resultWriter, result, entitySource, ODataVersion.V4, this.QueryContext.QuerySelectExpandClause, this.RequestHeaders);
}
}
else
{
ODataProperty property = new ODataProperty()
{
Name = "value", Value = ODataObjectModelConverter.CreateODataValue(result)
};
messageWriter.WriteProperty(property);
}
}
}
public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
object result;
if (this.HttpMethod == HttpMethod.GET)
{
// we cannot invoke same action request multiple times, so only Functions are allowed to do the server-driven paging
this.QueryContext.InitializeServerDrivenPaging(this.PreferenceContext);
result = this.ProcessFunction();
if (this.PreferenceContext.MaxPageSize.HasValue)
{
responseMessage.AddPreferenceApplied(string.Format("{0}={1}", ServiceConstants.Preference_MaxPageSize, this.QueryContext.appliedPageSize.Value));
}
}
else
{
// TODO: currently ETag feature does not support action operation
result = this.ProcessAction(requestMessage);
}
if (result == null)
{
// Protocol 9.1.4 Response Code 204 No Content
// A request returns 204 No Content if the requested resource has the null value,
// or if the service applies a return=minimal preference. In this case, the response body MUST be empty.
ResponseWriter.WriteEmptyResponse(responseMessage);
return;
}
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
if (this.QueryContext.Target.TypeKind == EdmTypeKind.None ||
this.QueryContext.Target.TypeKind == EdmTypeKind.EntityReference ||
this.QueryContext.Target.ElementTypeKind == EdmTypeKind.EntityReference)
{
throw Utility.BuildException(HttpStatusCode.NotImplemented, "Unsupported return type in operation.", null);
}
else if (this.QueryContext.Target.TypeKind == EdmTypeKind.Entity || this.QueryContext.Target.ElementTypeKind == EdmTypeKind.Entity)
{
ODataWriter resultWriter;
IEdmNavigationSource entitySource = this.QueryContext.OperationResultSource ?? this.QueryContext.Target.NavigationSource;
if (this.QueryContext.Target.TypeKind == EdmTypeKind.Collection)
{
IEdmEntitySetBase entitySet = (IEdmEntitySetBase)entitySource;
resultWriter = messageWriter.CreateODataFeedWriter(entitySet, (IEdmEntityType)this.QueryContext.Target.ElementType);
ResponseWriter.WriteFeed(resultWriter, (IEdmEntityType)this.QueryContext.Target.ElementType, result as IEnumerable, entitySet, ODataVersion.V4, this.QueryContext.QuerySelectExpandClause, this.QueryContext.TotalCount, null, this.QueryContext.NextLink, this.RequestHeaders);
}
else
{
if (this.HttpMethod == HttpMethod.GET)
{
var currentETag = Utility.GetETagValue(result);
// if the current entity has ETag field
if (currentETag != null)
{
string requestETag;
if (Utility.TryGetIfNoneMatch(this.RequestHeaders, out requestETag) && (requestETag == ServiceConstants.ETagValueAsterisk || requestETag == currentETag))
{
ResponseWriter.WriteEmptyResponse(responseMessage, HttpStatusCode.NotModified);
return;
}
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
}
resultWriter = messageWriter.CreateODataEntryWriter(entitySource, (IEdmEntityType)this.QueryContext.Target.Type);
ResponseWriter.WriteEntry(resultWriter, result, entitySource, ODataVersion.V4, this.QueryContext.QuerySelectExpandClause, this.RequestHeaders);
}
}
else
{
ODataProperty property = new ODataProperty() { Name = "value", Value = ODataObjectModelConverter.CreateODataValue(result) };
messageWriter.WriteProperty(property);
}
}
}
/// <summary>Handles an exception when processing a batch response.</summary>
/// <param name='service'>Data service doing the processing.</param>
/// <param name="requestMessage">requestMessage holding information about the request that caused an error</param>
/// <param name="responseMessage">responseMessage to which we need to write the exception message</param>
/// <param name='exception'>Exception thrown.</param>
/// <param name='batchWriter'>Output writer for the batch.</param>
/// <param name="responseStream">Underlying response stream.</param>
/// <param name="defaultResponseVersion">The data service version to use for response, if it cannot be computed from the requestMessage.</param>
internal static void HandleBatchOperationError(IDataService service, AstoriaRequestMessage requestMessage, IODataResponseMessage responseMessage, Exception exception, ODataBatchWriter batchWriter, Stream responseStream, Version defaultResponseVersion)
{
Debug.Assert(service != null, "service != null");
Debug.Assert(exception != null, "exception != null");
Debug.Assert(batchWriter != null, "batchWriter != null");
Debug.Assert(service.Configuration != null, "service.Configuration != null");
Debug.Assert(CommonUtil.IsCatchableExceptionType(exception), "CommonUtil.IsCatchableExceptionType(exception)");
ErrorHandler handler = CreateHandler(service, requestMessage, exception, defaultResponseVersion);
service.InternalHandleException(handler.exceptionArgs);
if (requestMessage != null && responseMessage != null)
{
responseMessage.SetHeader(XmlConstants.HttpODataVersion, handler.responseVersion.ToString(2) + ";");
requestMessage.ProcessException(handler.exceptionArgs);
// if ProcessBenignException returns anything, we can safely not write to the stream.
if (ProcessBenignException(exception, service) != null)
{
return;
}
}
if (requestMessage != null)
{
responseMessage = requestMessage.BatchServiceHost.GetOperationResponseMessage();
WebUtil.SetResponseHeadersForBatchRequests(responseMessage, requestMessage.BatchServiceHost);
}
else
{
responseMessage = batchWriter.CreateOperationResponseMessage(null);
responseMessage.StatusCode = handler.exceptionArgs.ResponseStatusCode;
}
MessageWriterBuilder messageWriterBuilder = MessageWriterBuilder.ForError(
null,
service,
handler.responseVersion,
responseMessage,
handler.contentType,
null /*acceptCharsetHeaderValue*/);
using (ODataMessageWriter messageWriter = messageWriterBuilder.CreateWriter())
{
ODataError error = handler.exceptionArgs.CreateODataError();
WriteErrorWithFallbackForXml(messageWriter, handler.encoding, responseStream, handler.exceptionArgs, error, messageWriterBuilder);
}
}
/// <summary>Initializes a new <see cref="ResponseBodyWriter"/> that can write the body of a response.</summary>
/// <param name="service">Service for the request being processed.</param>
/// <param name="queryResults">Enumerator for results.</param>
/// <param name="requestDescription">Description of request made to the system.</param>
/// <param name="actualResponseMessageWhoseHeadersMayBeOverridden">IODataResponseMessage instance for the response.</param>
internal ResponseBodyWriter(
IDataService service,
QueryResultInfo queryResults,
RequestDescription requestDescription,
IODataResponseMessage actualResponseMessageWhoseHeadersMayBeOverridden)
{
Debug.Assert(service != null, "service != null");
Debug.Assert(requestDescription != null, "requestDescription != null");
Debug.Assert(actualResponseMessageWhoseHeadersMayBeOverridden != null, "actualResponseMessageWhoseHeadersMayBeOverridden != null");
this.service = service;
this.queryResults = queryResults;
this.requestDescription = requestDescription;
this.actualResponseMessageWhoseHeadersMayBeOverridden = actualResponseMessageWhoseHeadersMayBeOverridden;
Debug.Assert(this.PayloadKind != ODataPayloadKind.Unsupported, "payloadKind != ODataPayloadKind.Unsupported");
this.encoding = ContentTypeUtil.EncodingFromAcceptCharset(this.service.OperationContext.RequestMessage.GetRequestAcceptCharsetHeader());
if (this.PayloadKind == ODataPayloadKind.Entry ||
this.PayloadKind == ODataPayloadKind.Feed ||
this.PayloadKind == ODataPayloadKind.Property ||
this.PayloadKind == ODataPayloadKind.Collection ||
this.PayloadKind == ODataPayloadKind.EntityReferenceLink ||
this.PayloadKind == ODataPayloadKind.EntityReferenceLinks ||
this.PayloadKind == ODataPayloadKind.Error ||
this.PayloadKind == ODataPayloadKind.ServiceDocument ||
this.PayloadKind == ODataPayloadKind.Parameter)
{
AstoriaRequestMessage requestMessage = service.OperationContext.RequestMessage;
IODataResponseMessage responseMessageOnOperationContext = service.OperationContext.ResponseMessage;
Version effectiveMaxResponseVersion = VersionUtil.GetEffectiveMaxResponseVersion(service.Configuration.DataServiceBehavior.MaxProtocolVersion.ToVersion(), requestMessage.RequestMaxVersion);
bool isEntityOrFeed = this.PayloadKind == ODataPayloadKind.Entry || this.PayloadKind == ODataPayloadKind.Feed;
if (ContentTypeUtil.IsResponseMediaTypeJsonLight(requestMessage.GetAcceptableContentTypes(), isEntityOrFeed, effectiveMaxResponseVersion))
{
// If JSON light 'wins', then bump the version to V3.
requestDescription.VerifyAndRaiseResponseVersion(VersionUtil.Version4Dot0, service);
responseMessageOnOperationContext.SetHeader(XmlConstants.HttpODataVersion, XmlConstants.ODataVersion4Dot0 + ";");
}
}
if (this.requestDescription.TargetKind == RequestTargetKind.MediaResource)
{
Debug.Assert(this.PayloadKind == ODataPayloadKind.BinaryValue, "payloadKind == ODataPayloadKind.BinaryValue");
// Note that GetReadStream will set the ResponseETag before it returns
this.mediaResourceStream = service.StreamProvider.GetReadStream(
this.queryResults.Current,
this.requestDescription.StreamProperty,
this.service.OperationContext);
}
else if (this.PayloadKind != ODataPayloadKind.BinaryValue)
{
IEdmModel model;
if (this.PayloadKind == ODataPayloadKind.MetadataDocument)
{
model = MetadataSerializer.PrepareModelForSerialization(this.service.Provider, this.service.Configuration);
}
else
{
model = this.GetModelFromService();
}
// Create the message writer using which the response needs to be written.
this.messageWriterBuilder = MessageWriterBuilder.ForNormalRequest(
this.service,
this.requestDescription,
this.actualResponseMessageWhoseHeadersMayBeOverridden,
model);
this.messageWriter = this.messageWriterBuilder.CreateWriter();
try
{
// Make sure all the headers are written before the method returns.
this.contentFormat = ODataUtils.SetHeadersForPayload(this.messageWriter, this.PayloadKind);
}
catch (ODataContentTypeException contentTypeException)
{
throw new DataServiceException(415, null, Strings.DataServiceException_UnsupportedMediaType, null, contentTypeException);
}
Debug.Assert(requestDescription.ResponseFormat != null, "Response format should already have been determined.");
Debug.Assert(ReferenceEquals(this.contentFormat, requestDescription.ResponseFormat.Format), "Response format in request description did not match format when writing.");
if (this.PayloadKind == ODataPayloadKind.Value && !String.IsNullOrEmpty(this.requestDescription.MimeType))
{
this.actualResponseMessageWhoseHeadersMayBeOverridden.SetHeader(XmlConstants.HttpContentType, this.requestDescription.MimeType);
}
// EPM is currently removed, but this doesn't seem to be used for EPM only. The old comment was saying:
// In astoria, there is a bug in V1/V2 that while computing response version, we did not take
// epm into account. Hence while creating the writer, we need to pass the RequestDescription.ActualResponseVersion
// so that ODataLib can do the correct payload validation. But we need to write the response version without
// the epm into the response headers because of backward-compat issue. Hence over-writing the response version
// header with the wrong version value.
string responseVersion = this.requestDescription.ResponseVersion.ToString() + ";";
this.actualResponseMessageWhoseHeadersMayBeOverridden.SetHeader(XmlConstants.HttpODataVersion, responseVersion);
}
}
public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
if (this.TryDispatch(requestMessage, responseMessage))
{
return;
}
this.QueryContext.InitializeServerDrivenPaging(this.PreferenceContext);
this.QueryContext.InitializeTrackingChanges(this.PreferenceContext);
object queryResults = this.QueryContext.ResolveQuery(this.DataSource);
if (queryResults == null)
{
// For individual property or $value
if (this.QueryContext.Target.Property != null)
{
// Protocol 9.1.4 Response Code 204 No Content
// A request returns 204 No Content if the requested resource has the null value,
// or if the service applies a return=minimal preference. In this case, the response body MUST be empty.
ResponseWriter.WriteEmptyResponse(responseMessage);
return;
}
else
{
throw Utility.BuildException(HttpStatusCode.NotFound);
}
}
// Handle the prefer of "odata.include-annotations", including it in response header
if (!string.IsNullOrEmpty(this.PreferenceContext.IncludeAnnotations))
{
responseMessage.AddPreferenceApplied(string.Format("{0}={1}",
ServiceConstants.Preference_IncludeAnnotations, this.PreferenceContext.IncludeAnnotations));
}
if (this.PreferenceContext.MaxPageSize.HasValue)
{
responseMessage.AddPreferenceApplied(string.Format("{0}={1}", ServiceConstants.Preference_MaxPageSize, this.QueryContext.appliedPageSize.Value));
}
if (this.PreferenceContext.TrackingChanges)
{
responseMessage.AddPreferenceApplied(ServiceConstants.Preference_TrackChanging);
}
responseMessage.SetStatusCode(HttpStatusCode.OK);
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
IEdmNavigationSource navigationSource = this.QueryContext.Target.NavigationSource;
IEnumerable iEnumerableResults = queryResults as IEnumerable;
if (this.QueryContext.Target.IsReference && this.QueryContext.Target.TypeKind == EdmTypeKind.Collection)
{
// Query a $ref collection
IList<ODataEntityReferenceLink> links = new List<ODataEntityReferenceLink>();
foreach (var iEnumerableResult in iEnumerableResults)
{
var link = new ODataEntityReferenceLink
{
Url = Utility.BuildLocationUri(this.QueryContext, iEnumerableResult),
};
links.Add(link);
}
ODataEntityReferenceLinks linksCollection = new ODataEntityReferenceLinks() { Links = links, NextPageLink = this.QueryContext.NextLink };
linksCollection.InstanceAnnotations.Add(new ODataInstanceAnnotation("Links.Annotation", new ODataPrimitiveValue(true)));
messageWriter.WriteEntityReferenceLinks(linksCollection);
}
else if (this.QueryContext.Target.IsReference && this.QueryContext.Target.TypeKind == EdmTypeKind.Entity)
{
// Query a $ref
var link = new ODataEntityReferenceLink
{
Url = Utility.BuildLocationUri(this.QueryContext, queryResults),
};
link.InstanceAnnotations.Add(new ODataInstanceAnnotation("Link.Annotation", new ODataPrimitiveValue(true)));
messageWriter.WriteEntityReferenceLink(link);
}
else if (this.QueryContext.Target.NavigationSource != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Collection)
{
// Query a feed
IEdmEntitySetBase entitySet = navigationSource as IEdmEntitySetBase;
IEdmEntityType entityType = this.QueryContext.Target.ElementType as IEdmEntityType;
if (entitySet == null || entityType == null)
{
throw new InvalidOperationException("Invalid target when query feed.");
}
ODataWriter resultWriter = messageWriter.CreateODataFeedWriter(entitySet, entityType);
ResponseWriter.WriteFeed(resultWriter, entityType, iEnumerableResults, entitySet, ODataVersion.V4, this.QueryContext.QuerySelectExpandClause, this.QueryContext.TotalCount, this.QueryContext.DeltaLink, this.QueryContext.NextLink, this.RequestHeaders);
resultWriter.Flush();
}
else if (this.QueryContext.Target.NavigationSource != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Entity)
{
var currentETag = Utility.GetETagValue(queryResults);
// if the current entity has ETag field
if (currentETag != null)
{
string requestETag;
if (Utility.TryGetIfNoneMatch(this.RequestHeaders, out requestETag) && (requestETag == ServiceConstants.ETagValueAsterisk || requestETag == currentETag))
{
ResponseWriter.WriteEmptyResponse(responseMessage, HttpStatusCode.NotModified);
return;
}
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
// Query a single entity
IEdmEntityType entityType = this.QueryContext.Target.Type as IEdmEntityType;
ODataWriter resultWriter = messageWriter.CreateODataEntryWriter(navigationSource, entityType);
ResponseWriter.WriteEntry(resultWriter, queryResults, navigationSource, ODataVersion.V4, this.QueryContext.QuerySelectExpandClause, this.RequestHeaders);
resultWriter.Flush();
}
else if (this.QueryContext.Target.Property != null && !this.QueryContext.Target.IsRawValue)
{
// Query a individual property
ODataProperty property = ODataObjectModelConverter.CreateODataProperty(queryResults, this.QueryContext.Target.Property.Name);
messageWriter.WriteProperty(property);
}
else if (this.QueryContext.Target.IsRawValue)
{
// Query a $value or $count
var propertyValue = ODataObjectModelConverter.CreateODataValue(queryResults);
messageWriter.WriteValue(propertyValue);
}
else
{
throw Utility.BuildException(HttpStatusCode.NotImplemented);
}
}
}
/// <summary>
/// Write empty response and set the HttpStatusCode to 202 Accepted
/// </summary>
/// <param name="responseMessage"></param>
/// <param name="asyncToken"></param>
public static void WriteAsyncPendingResponse(IODataResponseMessage responseMessage, string asyncToken)
{
responseMessage.SetStatusCode(HttpStatusCode.Accepted);
responseMessage.SetHeader(ServiceConstants.HttpHeaders.DataServiceVersion, "4.0");
Uri location = new Uri(ServiceConstants.ServiceBaseUri, string.Format("{0}?{1}={2}", ServiceConstants.ServicePath_Async, ServiceConstants.QueryOption_AsyncToken, asyncToken));
responseMessage.SetHeader(ServiceConstants.HttpHeaders.Location, location.OriginalString);
if (!(responseMessage is ODataBatchOperationResponseMessage))
{
using (responseMessage.GetStream())
{
}
}
}
/// <summary>
/// Write empty response and set the HttpStatusCode to 204 NoContent
/// </summary>
/// <param name="responseMessage"></param>
public static void WriteEmptyResponse(IODataResponseMessage responseMessage, HttpStatusCode statusCode = HttpStatusCode.NoContent)
{
responseMessage.SetStatusCode(statusCode);
responseMessage.SetHeader("OData-Version", "4.0");
if (!(responseMessage is ODataBatchOperationResponseMessage))
{
using (responseMessage.GetStream())
{
}
}
}
public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
if (this.TryDispatch(requestMessage, responseMessage))
{
return;
}
this.QueryContext.InitializeServerDrivenPaging(this.PreferenceContext);
this.QueryContext.InitializeTrackingChanges(this.PreferenceContext);
object queryResults = this.QueryContext.ResolveQuery(this.DataSource);
if (queryResults == null)
{
// For individual property or $value
if (this.QueryContext.Target.Property != null)
{
// Protocol 9.1.4 Response Code 204 No Content
// A request returns 204 No Content if the requested resource has the null value,
// or if the service applies a return=minimal preference. In this case, the response body MUST be empty.
ResponseWriter.WriteEmptyResponse(responseMessage);
return;
}
else
{
throw Utility.BuildException(HttpStatusCode.NotFound);
}
}
// Handle the prefer of "odata.include-annotations", including it in response header
if (!string.IsNullOrEmpty(this.PreferenceContext.IncludeAnnotations))
{
responseMessage.AddPreferenceApplied(string.Format("{0}={1}",
ServiceConstants.Preference_IncludeAnnotations, this.PreferenceContext.IncludeAnnotations));
}
if (this.PreferenceContext.MaxPageSize.HasValue)
{
responseMessage.AddPreferenceApplied(string.Format("{0}={1}", ServiceConstants.Preference_MaxPageSize, this.QueryContext.appliedPageSize.Value));
}
if (this.PreferenceContext.TrackingChanges)
{
responseMessage.AddPreferenceApplied(ServiceConstants.Preference_TrackChanging);
}
responseMessage.SetStatusCode(HttpStatusCode.OK);
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
IEdmNavigationSource navigationSource = this.QueryContext.Target.NavigationSource;
IEnumerable iEnumerableResults = queryResults as IEnumerable;
if (this.QueryContext.Target.IsReference && this.QueryContext.Target.TypeKind == EdmTypeKind.Collection)
{
// Query a $ref collection
IList <ODataEntityReferenceLink> links = new List <ODataEntityReferenceLink>();
foreach (var iEnumerableResult in iEnumerableResults)
{
var link = new ODataEntityReferenceLink
{
Url = Utility.BuildLocationUri(this.QueryContext, iEnumerableResult),
};
links.Add(link);
}
ODataEntityReferenceLinks linksCollection = new ODataEntityReferenceLinks()
{
Links = links, NextPageLink = this.QueryContext.NextLink
};
linksCollection.InstanceAnnotations.Add(new ODataInstanceAnnotation("Links.Annotation", new ODataPrimitiveValue(true)));
messageWriter.WriteEntityReferenceLinks(linksCollection);
}
else if (this.QueryContext.Target.IsReference && this.QueryContext.Target.TypeKind == EdmTypeKind.Entity)
{
// Query a $ref
var link = new ODataEntityReferenceLink
{
Url = Utility.BuildLocationUri(this.QueryContext, queryResults),
};
link.InstanceAnnotations.Add(new ODataInstanceAnnotation("Link.Annotation", new ODataPrimitiveValue(true)));
messageWriter.WriteEntityReferenceLink(link);
}
else if (this.QueryContext.Target.NavigationSource != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Collection)
{
// Query a feed
IEdmEntitySetBase entitySet = navigationSource as IEdmEntitySetBase;
IEdmEntityType entityType = this.QueryContext.Target.ElementType as IEdmEntityType;
if (entitySet == null || entityType == null)
{
throw new InvalidOperationException("Invalid target when query feed.");
}
ODataWriter resultWriter = messageWriter.CreateODataFeedWriter(entitySet, entityType);
ResponseWriter.WriteFeed(resultWriter, iEnumerableResults, entitySet, ODataVersion.V4, this.QueryContext.QuerySelectExpandClause, this.QueryContext.TotalCount, this.QueryContext.DeltaLink, this.QueryContext.NextLink, this.RequestHeaders);
resultWriter.Flush();
}
else if (this.QueryContext.Target.NavigationSource != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Entity)
{
var currentETag = Utility.GetETagValue(queryResults);
// if the current entity has ETag field
if (currentETag != null)
{
string requestETag;
if (Utility.TryGetIfNoneMatch(this.RequestHeaders, out requestETag) && (requestETag == ServiceConstants.ETagValueAsterisk || requestETag == currentETag))
{
ResponseWriter.WriteEmptyResponse(responseMessage, HttpStatusCode.NotModified);
return;
}
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
// Query a single entity
IEdmEntityType entityType = this.QueryContext.Target.Type as IEdmEntityType;
ODataWriter resultWriter = messageWriter.CreateODataEntryWriter(navigationSource, entityType);
ResponseWriter.WriteEntry(resultWriter, queryResults, navigationSource, ODataVersion.V4, this.QueryContext.QuerySelectExpandClause, this.RequestHeaders);
resultWriter.Flush();
}
else if (this.QueryContext.Target.Property != null && !this.QueryContext.Target.IsRawValue)
{
// Query a individual property
ODataProperty property = ODataObjectModelConverter.CreateODataProperty(queryResults, this.QueryContext.Target.Property.Name);
messageWriter.WriteProperty(property);
}
else if (this.QueryContext.Target.IsRawValue)
{
// Query a $value or $count
var propertyValue = ODataObjectModelConverter.CreateODataValue(queryResults);
messageWriter.WriteValue(propertyValue);
}
else
{
throw Utility.BuildException(HttpStatusCode.NotImplemented);
}
}
}
private void ProcessUpdateRequestBody(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage, object targetObject, bool isUpsert)
{
if (this.QueryContext.Target.NavigationSource != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Entity)
{
using (var messageReader = new ODataMessageReader(requestMessage, this.GetReaderSettings(), this.DataSource.Model))
{
var entryReader = messageReader.CreateODataEntryReader(this.QueryContext.Target.NavigationSource, (IEdmEntityType)this.QueryContext.Target.Type);
while (entryReader.Read())
{
switch (entryReader.State)
{
case ODataReaderState.EntryEnd:
var entry = (ODataEntry)entryReader.Item;
foreach (var property in entry.Properties)
{
if (Utility.IsETagProperty(targetObject, property.Name))
{
continue;
}
// the property might be an open property, so test null first
var propertyInfo = targetObject.GetType().GetProperty(property.Name);
if (propertyInfo != null)
{
if (!isUpsert && Utility.IsReadOnly(propertyInfo))
{
continue;
}
}
this.DataSource.UpdateProvider.Update(targetObject, property.Name, property.Value);
}
break;
}
}
}
}
else if (this.QueryContext.Target.Property != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Complex)
{
using (var messageReader = new ODataMessageReader(requestMessage, this.GetReaderSettings(), this.DataSource.Model))
{
var property = messageReader.ReadProperty(this.QueryContext.Target.Property);
ODataComplexValue complexValue = property.Value as ODataComplexValue;
foreach (var p in complexValue.Properties)
{
if (Utility.IsETagProperty(targetObject, property.Name))
{
continue;
}
this.DataSource.UpdateProvider.Update(targetObject, p.Name, p.Value);
}
}
}
else
{
throw Utility.BuildException(
HttpStatusCode.NotImplemented,
string.Format("PATCH/PUT for '{0}' type is not supported.", this.QueryContext.Target.TypeKind),
null);
}
var currentETag = Utility.GetETagValue(targetObject);
// if the current entity has ETag field
if (currentETag != null)
{
if (!isUpsert)
{
this.DataSource.UpdateProvider.UpdateETagValue(targetObject);
}
this.DataSource.UpdateProvider.SaveChanges();
currentETag = Utility.GetETagValue(targetObject);
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
else
{
this.DataSource.UpdateProvider.SaveChanges();
}
ResponseWriter.WriteEmptyResponse(responseMessage);
}
private ODataAsynchronousReader CreateAsyncReader(string payload)
{
responseStream = new MemoryStream(Encoding.Default.GetBytes(payload));
responseMessage = new InMemoryMessage { Stream = responseStream };
responseMessage.SetHeader("Content-Type", "application/http");
responseMessage.SetHeader("Content-Transfer-Encoding", "binary");
this.messageReader = new ODataMessageReader(responseMessage, new ODataMessageReaderSettings(), userModel);
return this.messageReader.CreateODataAsynchronousReader();
}