public static async Task SerializeAsync(Uri baseUri, OeParseUriContext parseUriContext, Db.OeEntityAsyncEnumerator asyncEnumerator, Stream stream)
{
IEdmModel edmModel = parseUriContext.EdmModel;
OeEntryFactory entryFactory = parseUriContext.EntryFactory;
String contentType = parseUriContext.Headers.ContentType;
var settings = new ODataMessageWriterSettings()
{
BaseUri = baseUri,
EnableMessageStreamDisposal = false,
ODataUri = parseUriContext.ODataUri,
Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, contentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, edmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(entryFactory.EntitySet, entryFactory.EntityType);
var getWriter = new GetWriter(baseUri, parseUriContext.Headers.MetadataLevel, writer);
await getWriter.SerializeAsync(entryFactory, asyncEnumerator, stream);
}
}
private OeEntityItem ReadEntityFromStream(OeMessageContext context, Stream content)
{
var parser = new ODataUriParser(context.Model, context.BaseUri, RequestUrl);
IEdmEntitySet entitySet;
IEdmEntityTypeReference entityTypeRef = GetEdmEntityTypeRef(parser.ParsePath(), out entitySet);
var entityType = (IEdmEntityType)entityTypeRef.Definition;
ODataResource entry = null;
IODataRequestMessage requestMessage = new OeInMemoryMessage(content, ContentType);
var settings = new ODataMessageReaderSettings {
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, context.Model))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entityType);
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
Db.OeEntitySetMetaAdapter entitySetMetaAdapter = context.EntitySetMetaAdapters.FindByEntitySetName(entitySet.Name);
return(new OeEntityItem(entitySet, entityType, entitySetMetaAdapter.EntityType, entry));
}
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 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 void WriteEntity(Stream stream, OeEntityItem entityItem)
{
var settings = new ODataMessageWriterSettings()
{
BaseUri = _baseUri,
Version = ODataVersion.V4,
ODataUri = new ODataUri()
{
ServiceRoot = _baseUri
},
EnableMessageStreamDisposal = false
};
IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, null);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, _model))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.Resource);
ODataWriter writer = messageWriter.CreateODataResourceWriter(entityItem.EntitySet, entityItem.EntityType);
entityItem.RefreshEntry();
writer.WriteStart(entityItem.Entry);
writer.WriteEnd();
}
}
private static ODataResource ReadEntityFromStream(IEdmModel edmModel, Uri baseUri, Stream content, Uri requestUrl, String contentType, out IEdmEntitySet entitySet)
{
var parser = new ODataUriParser(edmModel, baseUri, requestUrl);
IEdmEntityTypeReference entityTypeRef = GetEdmEntityTypeRef(parser.ParsePath(), out entitySet);
ODataResource entry = null;
IODataRequestMessage requestMessage = new 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);
}
public 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"]);
_metadataLevel = requestHeaders.MetadataLevel;
if (requestHeaders.MaxPageSize > 0 && PageSize == 0)
{
PageSize = requestHeaders.MaxPageSize;
}
IODataResponseMessage responseMessage = new OeInMemoryMessage(context.HttpContext.Response.Body, context.HttpContext.Request.ContentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, _edmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
IEdmEntitySet edmEntitySet = OeEdmClrHelper.GetEntitySet(_edmModel, typeof(T));
IEdmEntityType edmEntityType = edmEntitySet.EntityType();
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(edmEntitySet, edmEntityType);
await SerializeAsync(writer);
}
}
public static IEnumerable <KeyValuePair <String, Object> > ParseJson(IEdmModel model, String skipToken, IEnumerable <IEdmStructuralProperty> keys)
{
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(skipToken)))
{
IODataRequestMessage requestMessage = new 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);
while (reader.Read())
{
Object value = reader.Value;
if (value is ODataEnumValue enumValue)
{
value = OeEdmClrHelper.GetValue(model, enumValue);
}
yield return(new KeyValuePair <String, Object>(reader.Name, value));
}
}
}
}
private void WriteEntity(Stream stream, OeEntityItem entityItem)
{
IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, null);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, _settings, _model))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.Resource);
ODataWriter writer = messageWriter.CreateODataResourceWriter(entityItem.EntitySet, entityItem.EntityType);
writer.WriteStart(entityItem.Entry);
writer.WriteEnd();
}
}
public void Write(Stream stream, OeBatchMessage batchMessage)
{
IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, batchMessage.ContentType);
var settings = new ODataMessageWriterSettings()
{
Version = ODataVersion.V4,
EnableMessageStreamDisposal = false,
MessageQuotas = new ODataMessageQuotas()
};
var messageWriter = new ODataMessageWriter(responseMessage, settings);
ODataBatchWriter writer = messageWriter.CreateODataBatchWriter();
writer.WriteStartBatch();
WriteBatch(writer, batchMessage);
writer.WriteEndBatch();
}
private IEnumerable <T> ReadFeedImpl <T>(Stream response, Db.OeEntitySetMetaAdapter entitySetMetaAdatpter)
{
IODataRequestMessage responseMessage = new OeInMemoryMessage(response, null);
var settings = new ODataMessageReaderSettings()
{
EnableMessageStreamDisposal = false
};
var messageReader = new ODataMessageReader(responseMessage, settings, _edmModel);
IEdmEntitySet entitySet = _edmModel.EntityContainer.FindEntitySet(entitySetMetaAdatpter.EntitySetName);
ODataReader reader = messageReader.CreateODataResourceSetReader(entitySet, entitySet.EntityType());
var stack = new Stack <StackItem>();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceStart:
stack.Push(new StackItem((ODataResource)reader.Item));
break;
case ODataReaderState.ResourceEnd:
StackItem stackItem = stack.Pop();
Object entity = CreateEntity(stackItem);
if (stack.Count == 0)
{
yield return((T)entity);
}
else
{
stack.Peek().AddEntry(entity);
}
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);
break;
}
}
}
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.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, contentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, queryContext.EdmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(entryFactory.EntitySet, entryFactory.EntityType);
var getWriter = new GetWriter(queryContext, writer);
await getWriter.SerializeAsync(entryFactory, asyncEnumerator, queryContext).ConfigureAwait(false);
}
}
public static OeBatchMessage CreateBatchMessage(OeMessageContext context, Stream requestStream, String contentType)
{
IODataRequestMessage requestMessage = new OeInMemoryMessage(requestStream, contentType);
var settings = new ODataMessageReaderSettings()
{
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings))
{
var batchMessage = new List <OeBatchMessage>();
ODataBatchReader batchReader = messageReader.CreateODataBatchReader();
while (batchReader.Read())
{
if (batchReader.State == ODataBatchReaderState.ChangesetStart)
{
var operations = new List <OeOperationMessage>();
while (batchReader.Read() && batchReader.State != ODataBatchReaderState.ChangesetEnd)
{
if (batchReader.State == ODataBatchReaderState.Operation)
{
OeOperationMessage operation = OeOperationMessage.Create(context, batchReader);
operations.Add(operation);
}
}
return(new OeBatchMessage(contentType, operations));
}
else if (batchReader.State == ODataBatchReaderState.Operation)
{
OeOperationMessage operation = OeOperationMessage.Create(context, batchReader);
return(new OeBatchMessage(contentType, operation));
}
}
}
throw new InvalidOperationException("batch not found");
}
public static String GetJson(IEdmModel model, IEnumerable <KeyValuePair <String, Object> > keys)
{
using (var stream = new MemoryStream())
{
IODataRequestMessage requestMessage = new OeInMemoryMessage(stream, null);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, WriterSettings, model))
{
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));
}
}
public IEnumerable <JObject> ReadOpenType(Stream response, Type baseEntityType)
{
IODataRequestMessage responseMessage = new OeInMemoryMessage(response, null);
var settings = new ODataMessageReaderSettings()
{
Validations = ValidationKinds.None, EnableMessageStreamDisposal = false
};
var messageReader = new ODataMessageReader(responseMessage, settings, _edmModel);
IEdmEntitySet entitySet = _edmModel.EntityContainer.EntitySets().Single(e => e.Type.AsElementType().FullTypeName() == baseEntityType.FullName);
ODataReader reader = messageReader.CreateODataResourceSetReader(entitySet, entitySet.EntityType());
StackItem stackItem;
var stack = new Stack <StackItem>();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceSetStart:
stack.Push(new StackItem((ODataResourceSet)reader.Item));
break;
case ODataReaderState.ResourceSetEnd:
stackItem = stack.Pop();
if (stack.Count == 0)
{
if (stackItem.Value != null)
{
foreach (StackItem entry in (IList)stackItem.Value)
{
yield return((JObject)CreateOpenTypeEntity(entry));
}
}
}
else
{
var entries = (IList)CreateOpenTypeEntity(stackItem);
stack.Peek().AddEntry(entries);
}
break;
case ODataReaderState.ResourceStart:
stack.Push(new StackItem((ODataResource)reader.Item));
break;
case ODataReaderState.ResourceEnd:
stackItem = stack.Pop();
if (stack.Count == 0)
{
yield return((JObject)CreateOpenTypeEntity(stackItem));
}
else
{
stack.Peek().AddEntry(stackItem);
}
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);
break;
}
}
}
protected IEnumerable ReadImpl(Stream response, Db.OeEntitySetMetaAdapter entitySetMetaAdatpter)
{
ResourceSet = null;
NavigationProperties.Clear();
NavigationPropertyEntities.Clear();
IODataResponseMessage responseMessage = new OeInMemoryMessage(response, null);
var settings = new ODataMessageReaderSettings()
{
EnableMessageStreamDisposal = false, Validations = ValidationKinds.None
};
var messageReader = new ODataMessageReader(responseMessage, settings, EdmModel);
IEdmEntitySet entitySet = EdmModel.EntityContainer.FindEntitySet(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;
}
}
}
