private ODataResource ReadEntityFromStream(Stream content, Uri requestUrl, String contentType, out IEdmEntitySet entitySet)
{
ODataUri odataUri = OeParser.ParseUri(_edmModel, _baseUri, requestUrl);
entitySet = ((EntitySetSegment)odataUri.Path.FirstSegment).EntitySet;
_edmEntityType = entitySet.EntityType();
IEdmModel edmModel = _edmModel.GetEdmModel(entitySet);
ODataResource entry = null;
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(content, contentType, _serviceProvider);
var settings = new ODataMessageReaderSettings
{
ClientCustomTypeResolver = ClientCustomTypeResolver,
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entitySet.EntityType());
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
return(entry);
}
public static async Task SerializeAsync(OeQueryContext queryContext, IAsyncEnumerator <Object> asyncEnumerator,
String contentType, Stream stream, OeEntryFactory entryFactory, IServiceProvider?serviceProvider, CancellationToken cancellationToken)
{
var settings = new ODataMessageWriterSettings()
{
BaseUri = queryContext.ODataUri.ServiceRoot,
EnableMessageStreamDisposal = false,
ODataUri = queryContext.ODataUri,
Validations = ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
if (serviceProvider != null)
{
serviceProvider = new ServiceProvider(serviceProvider, settings);
}
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(stream, contentType, serviceProvider);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, queryContext.EdmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
ODataWriter writer = await messageWriter.CreateODataResourceSetWriterAsync(entryFactory.EntitySet, entryFactory.EdmEntityType);
var odataWriter = new OeODataWriter(queryContext, writer, cancellationToken);
await odataWriter.WriteAsync(entryFactory, asyncEnumerator).ConfigureAwait(false);
}
}
public static async Task WriteCollectionAsync(IEdmModel edmModel, ODataUri odataUri, IAsyncEnumerator <Object> asyncEnumerator, Stream responseStream)
{
var importSegment = (OperationImportSegment)odataUri.Path.LastSegment;
IEdmOperationImport operationImport = importSegment.OperationImports.Single();
Type returnType = edmModel.GetClrType(operationImport.Operation.ReturnType.Definition);
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(responseStream, null);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage,
new ODataMessageWriterSettings()
{
EnableMessageStreamDisposal = false, ODataUri = odataUri
}, edmModel))
{
IEdmTypeReference typeRef = OeEdmClrHelper.GetEdmTypeReference(edmModel, returnType);
ODataCollectionWriter writer = await messageWriter.CreateODataCollectionWriterAsync(typeRef).ConfigureAwait(false);
await writer.WriteStartAsync(new ODataCollectionStart()).ConfigureAwait(false);
while (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false))
{
Object value = asyncEnumerator.Current;
if (value != null && value.GetType().IsEnum)
{
value = value.ToString();
}
await writer.WriteItemAsync(value).ConfigureAwait(false);
}
await writer.WriteEndAsync().ConfigureAwait(false);
}
}
public virtual async Task ExecuteResultAsync(ActionContext context)
{
var settings = new ODataMessageWriterSettings()
{
BaseUri = _odataUri.ServiceRoot,
EnableMessageStreamDisposal = false,
ODataUri = _odataUri,
Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
var requestHeaders = OeRequestHeaders.Parse(context.HttpContext.Request.Headers["Accept"], context.HttpContext.Request.Headers["Prefer"]);
if (requestHeaders.MaxPageSize > 0 && PageSize == 0)
{
PageSize = requestHeaders.MaxPageSize;
}
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(context.HttpContext.Response.Body, context.HttpContext.Request.ContentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, _edmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
IEdmEntityType entityType = _resultEntitySet.EntityType();
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(_resultEntitySet, entityType);
await SerializeAsync(writer, requestHeaders.MetadataLevel);
}
}
public async ValueTask WriteOperationAsync(Stream stream, OeOperationMessage operation)
{
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(stream, operation.ContentType);
using (var messageWriter = new ODataMessageWriter(responseMessage, _settings))
await WriteEntityAsync(operation.EntitySet, operation.Entry, stream).ConfigureAwait(false);
}
private static OeSkipTokenNameValue[] ParseJson(IEdmModel model, String skipToken, IEdmStructuralProperty[] keys)
{
var skipTokenNameValues = new OeSkipTokenNameValue[keys.Length];
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(skipToken)))
{
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(stream, null);
using (ODataMessageReader messageReader = new ODataMessageReader(requestMessage, ReaderSettings, model))
{
var operation = new EdmAction("", "", null);
foreach (IEdmStructuralProperty key in keys)
{
operation.AddParameter(GetPropertyName(key), key.Type);
}
ODataParameterReader reader = messageReader.CreateODataParameterReader(operation);
int i = 0;
while (reader.Read())
{
Object value = reader.Value;
if (value is ODataEnumValue enumValue)
{
value = OeEdmClrHelper.GetValue(model, enumValue);
}
skipTokenNameValues[i++] = new OeSkipTokenNameValue(reader.Name, value);
}
}
}
return(skipTokenNameValues);
}
private static ODataResource ReadEntityFromStream(IEdmModel edmModel, Uri baseUri, Stream content, Uri requestUrl, String contentType, out IEdmEntitySet entitySet)
{
ODataUri odataUri = OeParser.ParseUri(edmModel, baseUri, requestUrl);
IEdmEntityTypeReference entityTypeRef = GetEdmEntityTypeRef(odataUri.Path, out entitySet);
edmModel = edmModel.GetEdmModel(entitySet);
ODataResource entry = null;
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(content, contentType);
var settings = new ODataMessageReaderSettings {
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entitySet.EntityType());
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
return(entry);
}
private static void FillParameters(IEdmModel edmModel, List <KeyValuePair <String, Object> > parameters, Stream requestStream, IEdmOperation operation, String contentType)
{
if (!operation.Parameters.Any())
{
return;
}
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(requestStream, contentType);
var settings = new ODataMessageReaderSettings()
{
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
{
ODataParameterReader parameterReader = messageReader.CreateODataParameterReader(operation);
while (parameterReader.Read())
{
Object value;
switch (parameterReader.State)
{
case ODataParameterReaderState.Value:
{
value = OeEdmClrHelper.GetValue(edmModel, parameterReader.Value);
break;
}
case ODataParameterReaderState.Collection:
{
ODataCollectionReader collectionReader = parameterReader.CreateCollectionReader();
value = OeEdmClrHelper.GetValue(edmModel, ReadCollection(collectionReader));
break;
}
case ODataParameterReaderState.Resource:
{
ODataReader reader = parameterReader.CreateResourceReader();
value = OeEdmClrHelper.GetValue(edmModel, ReadResource(reader));
break;
}
case ODataParameterReaderState.ResourceSet:
{
ODataReader reader = parameterReader.CreateResourceSetReader();
value = OeEdmClrHelper.GetValue(edmModel, ReadResourceSet(reader));
break;
}
default:
continue;
}
parameters.Add(new KeyValuePair <String, Object>(parameterReader.Name, value));
}
}
}
private static async Task WriteMetadataAsync(IEdmModel edmModel, Stream stream)
{
var writerSettings = new ODataMessageWriterSettings();
writerSettings.EnableMessageStreamDisposal = false;
IODataResponseMessage message = new Infrastructure.OeInMemoryMessage(stream, null);
using (var writer = new ODataMessageWriter((IODataResponseMessageAsync)message, writerSettings, edmModel))
await writer.WriteMetadataDocumentAsync().ConfigureAwait(false);
}
private async Task WriteEntity(IEdmEntitySet entitySet, ODataResource entry, Stream stream)
{
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(stream, null);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, _settings, _model.GetEdmModel(entitySet)))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.Resource);
ODataWriter writer = await messageWriter.CreateODataResourceWriterAsync(entitySet, entitySet.EntityType());
await writer.WriteStartAsync(entry);
await writer.WriteEndAsync();
}
}
public async Task Write(Stream stream, OeBatchMessage batchMessage)
{
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(stream, batchMessage.ContentType);
using (var messageWriter = new ODataMessageWriter(responseMessage, _settings))
{
ODataBatchWriter writer = await messageWriter.CreateODataBatchWriterAsync().ConfigureAwait(false);
await writer.WriteStartBatchAsync().ConfigureAwait(false);
await WriteBatch(writer, batchMessage).ConfigureAwait(false);
await writer.WriteEndBatchAsync().ConfigureAwait(false);
}
}
private static async Task GetServiceDocument(IEdmModel edmModel, Uri baseUri, Stream stream)
{
var settings = new ODataMessageWriterSettings()
{
BaseUri = baseUri,
Version = ODataVersion.V4,
ODataUri = new ODataUri()
{
ServiceRoot = baseUri
},
EnableMessageStreamDisposal = false
};
ODataServiceDocument serviceDocument = ODataUtils.GenerateServiceDocument(edmModel);
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(stream, null);
using (var messageWriter = new ODataMessageWriter(responseMessage, settings))
await messageWriter.WriteServiceDocumentAsync(serviceDocument);
}
public static async Task SerializeAsync(OeQueryContext queryContext, Db.OeAsyncEnumerator asyncEnumerator, String contentType, Stream stream)
{
OeEntryFactory entryFactory = queryContext.EntryFactory;
var settings = new ODataMessageWriterSettings()
{
BaseUri = queryContext.ODataUri.ServiceRoot,
EnableMessageStreamDisposal = false,
ODataUri = queryContext.ODataUri,
Validations = ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(stream, contentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, queryContext.EdmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(entryFactory.EntitySet, entryFactory.EdmEntityType);
var getWriter = new GetWriter(queryContext, writer);
await getWriter.SerializeAsync(entryFactory, asyncEnumerator, queryContext).ConfigureAwait(false);
}
}
public static String GetJson(IEdmModel edmModel, IEnumerable <KeyValuePair <String, Object> > keys)
{
using (var stream = new MemoryStream())
{
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(stream, null);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, WriterSettings, edmModel))
{
ODataParameterWriter writer = messageWriter.CreateODataParameterWriter(null);
writer.WriteStart();
foreach (KeyValuePair <String, Object> key in keys)
{
Object value = key.Value;
if (value != null && value.GetType().IsEnum)
{
value = value.ToString();
}
writer.WriteValue(key.Key, value);
}
writer.WriteEnd();
}
return(Encoding.UTF8.GetString(stream.GetBuffer(), 0, (int)stream.Length));
}
}
protected IEnumerable Read(Stream response, Db.OeEntitySetAdapter entitySetMetaAdatpter)
{
ResourceSet = null;
NavigationProperties.Clear();
NavigationInfoEntities.Clear();
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(response, null, _serviceProvider);
var settings = new ODataMessageReaderSettings()
{
EnableMessageStreamDisposal = false, Validations = ValidationKinds.None
};
using (var messageReader = new ODataMessageReader(responseMessage, settings, EdmModel))
{
IEdmEntitySet entitySet = OeEdmClrHelper.GetEntitySet(EdmModel, entitySetMetaAdatpter.EntitySetName);
ODataReader reader = messageReader.CreateODataResourceSetReader(entitySet, entitySet.EntityType());
var stack = new Stack <StackItem>();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceSetStart:
if (stack.Count == 0)
{
ResourceSet = (ODataResourceSetBase)reader.Item;
}
else
{
stack.Peek().ResourceSet = (ODataResourceSetBase)reader.Item;
}
break;
case ODataReaderState.ResourceStart:
stack.Push(new StackItem((ODataResource)reader.Item));
break;
case ODataReaderState.ResourceEnd:
StackItem stackItem = stack.Pop();
if (reader.Item != null)
{
if (stack.Count == 0)
{
yield return(CreateRootEntity((ODataResource)stackItem.Item, stackItem.NavigationProperties, entitySetMetaAdatpter.EntityType));
}
else
{
stack.Peek().AddEntry(CreateEntity((ODataResource)stackItem.Item, stackItem.NavigationProperties));
}
}
break;
case ODataReaderState.NestedResourceInfoStart:
stack.Push(new StackItem((ODataNestedResourceInfo)reader.Item));
break;
case ODataReaderState.NestedResourceInfoEnd:
StackItem item = stack.Pop();
stack.Peek().AddLink((ODataNestedResourceInfo)item.Item, item.Value, item.ResourceSet);
break;
}
}
}
}
