public DefaultODataActionPayloadDeserializer(IEnumerable <IStringCorrector> stringCorrectors,
ODataDeserializerProvider deserializerProvider)
: base(deserializerProvider)
{
if (stringCorrectors == null)
{
throw new ArgumentNullException(nameof(stringCorrectors));
}
_stringCorrectors = stringCorrectors;
}
public DefaultODataActionParameterDeserializer(ODataDeserializerProvider deserializerProvider, System.Web.Http.Dependencies.IDependencyResolver dependencyResolver)
: base(ODataPayloadKind.Parameter)
{
if (dependencyResolver == null)
{
throw new ArgumentNullException(nameof(dependencyResolver));
}
_stringFormatterConvert = new ODataJsonDeSerializerStringCorrector(dependencyResolver.GetServices(typeof(IStringCorrector).GetTypeInfo()).Cast <IStringCorrector>().ToArray());
_odataJsonDeserializerEnumConverter = new ODataJsonDeSerializerEnumConverter();
}
private static object ConvertResourceSet(ODataMessageReader oDataMessageReader,
IEdmTypeReference edmTypeReference, ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType = edmTypeReference.AsCollection();
EdmEntitySet tempEntitySet = null;
if (collectionType.ElementType().IsEntity())
{
tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp",
collectionType.ElementType().AsEntity().EntityDefinition());
}
// TODO: Sam xu, can we use the parameter-less overload
ODataReader odataReader = oDataMessageReader.CreateODataUriParameterResourceSetReader(tempEntitySet,
collectionType.ElementType().AsStructured().StructuredDefinition());
ODataResourceSetWrapper resourceSet =
odataReader.ReadResourceOrResourceSet() as ODataResourceSetWrapper;
ODataDeserializerProvider deserializerProvider = readContext.InternalRequest.DeserializerProvider;
ODataResourceSetDeserializer resourceSetDeserializer =
(ODataResourceSetDeserializer)deserializerProvider.GetEdmTypeDeserializer(collectionType);
object result = resourceSetDeserializer.ReadInline(resourceSet, collectionType, readContext);
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
IEnumerable newEnumerable = enumerable;
if (collectionType.ElementType().IsEntity())
{
newEnumerable = CovertResourceSetIds(enumerable, resourceSet, collectionType, readContext);
}
if (readContext.IsUntyped)
{
return(newEnumerable.ConvertToEdmObject(collectionType));
}
else
{
IEdmTypeReference elementTypeReference = collectionType.ElementType();
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference,
readContext.Model);
IEnumerable castedResult =
CastMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new object[] { newEnumerable }) as IEnumerable;
return(castedResult);
}
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataMediaTypeFormatter"/> class.
/// </summary>
/// <param name="formatter">The <see cref="ODataMediaTypeFormatter"/> to copy settings from.</param>
/// <param name="version">The OData version that this formatter supports.</param>
/// <param name="request">The <see cref="HttpRequestMessage"/> for the per-request formatter instance.</param>
/// <remarks>This is a copy constructor to be used in <see cref="GetPerRequestFormatterInstance"/>.</remarks>
internal ODataMediaTypeFormatter(ODataMediaTypeFormatter formatter, ODataVersion version, HttpRequestMessage request)
{
if (formatter == null)
{
throw Error.ArgumentNull("formatter");
}
if (request == null)
{
throw Error.ArgumentNull("request");
}
Contract.Assert(formatter._serializerProvider != null);
Contract.Assert(formatter._deserializerProvider != null);
Contract.Assert(formatter._payloadKinds != null);
// Parameter 1: formatter
// Execept for the other two parameters, this constructor is a copy constructor, and we need to copy
// everything on the other instance.
// Parameter 1A: Copy this class's private fields and internal properties.
_serializerProvider = formatter._serializerProvider;
_deserializerProvider = formatter._deserializerProvider;
_payloadKinds = formatter._payloadKinds;
MessageReaderQuotas = formatter.MessageReaderQuotas;
MessageWriterQuotas = formatter.MessageWriterQuotas;
// Parameter 1B: Copy the base class's properties.
foreach (MediaTypeMapping mediaTypeMapping in formatter.MediaTypeMappings)
{
// MediaTypeMapping doesn't support clone, and its public surface area is immutable anyway.
MediaTypeMappings.Add(mediaTypeMapping);
}
RequiredMemberSelector = formatter.RequiredMemberSelector;
foreach (Encoding supportedEncoding in formatter.SupportedEncodings)
{
// Per-request formatters share the encoding instances with the parent formatter
SupportedEncodings.Add(supportedEncoding);
}
foreach (MediaTypeHeaderValue supportedMediaType in formatter.SupportedMediaTypes)
{
// Per-request formatters share the media type instances with the parent formatter
SupportedMediaTypes.Add(supportedMediaType);
}
// Parameter 2: version
_version = version;
// Parameter 3: request
Request = request;
}
internal ODataMediaTypeFormatter(ODataDeserializerProvider oDataDeserializerProvider, ODataSerializerProvider oDataSerializerProvider)
{
ODataDeserializerProvider = oDataDeserializerProvider;
Model = oDataDeserializerProvider.EdmModel;
ODataSerializerProvider = oDataSerializerProvider;
SupportedMediaTypes.Add(ODataFormatterConstants.ApplicationAtomXmlMediaType);
SupportedMediaTypes.Add(ODataFormatterConstants.ApplicationJsonMediaType);
SupportedMediaTypes.Add(ODataFormatterConstants.ApplicationXmlMediaType);
SupportedEncodings.Add(new UnicodeEncoding(bigEndian: false, byteOrderMark: true, throwOnInvalidBytes: true));
SupportedEncodings.Add(new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));
}
private static object ConvertCollection(ODataCollectionValue collectionValue,
IEdmTypeReference edmTypeReference, Type clrType, string parameterName,
ODataDeserializerContext readContext, IServiceProvider requestContainer)
{
Contract.Assert(collectionValue != null);
IEdmCollectionTypeReference collectionType = edmTypeReference as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataDeserializerProvider deserializerProvider =
requestContainer.GetRequiredService <ODataDeserializerProvider>();
ODataCollectionDeserializer deserializer =
(ODataCollectionDeserializer)deserializerProvider.GetEdmTypeDeserializer(collectionType);
object value = deserializer.ReadInline(collectionValue, collectionType, readContext);
if (value == null)
{
return(null);
}
IEnumerable collection = value as IEnumerable;
Contract.Assert(collection != null);
Type elementType;
if (!clrType.IsCollection(out elementType))
{
// EdmEntityCollectionObject and EdmComplexCollectionObject are collection types.
throw new ODataException(String.Format(CultureInfo.InvariantCulture,
SRResources.ParameterTypeIsNotCollection, parameterName, clrType));
}
IEnumerable newCollection;
if (CollectionDeserializationHelpers.TryCreateInstance(clrType, collectionType, elementType,
out newCollection))
{
collection.AddToCollection(newCollection, elementType, parameterName, clrType);
if (clrType.IsArray)
{
newCollection = CollectionDeserializationHelpers.ToArray(newCollection, elementType);
}
return(newCollection);
}
return(null);
}
private ODataDeserializer GetDeserializer(Type type, ODataPath path, IEdmModel model,
ODataDeserializerProvider deserializerProvider, out IEdmTypeReference expectedPayloadType)
{
expectedPayloadType = GetExpectedPayloadType(type, path, model);
if (expectedPayloadType != null)
{
return(deserializerProvider.GetEdmTypeDeserializer(expectedPayloadType));
}
else
{
return(deserializerProvider.GetODataDeserializer(model, type, Request));
}
}
/// <summary>
/// Gets the <see cref="ODataEdmTypeDeserializer"/> for the given EDM type.
/// The proxy provider will get the real provider to return the serializer.
/// </summary>
/// <param name="edmType">The EDM type.</param>
/// <returns>An <see cref="ODataEdmTypeDeserializer"/> that can deserialize the given EDM type.</returns>
public override ODataEdmTypeDeserializer GetEdmTypeDeserializer(IEdmTypeReference edmType)
{
if (this.api != null)
{
ODataDeserializerProvider provider = api.Context.GetApiService <ODataDeserializerProvider>();
if (provider != null)
{
return(provider.GetEdmTypeDeserializer(edmType));
}
}
// In case user uses his own controller or NonFound error for request
return(DefaultRestierDeserializerProvider.SingletonInstance.GetEdmTypeDeserializer(edmType));
}
private ODataMediaTypeFormatter(ODataMediaTypeFormatter formatter, ODataVersion version,
HttpRequestMessage request)
{
Contract.Assert(formatter._serializerProvider != null);
Contract.Assert(formatter._model != null);
Contract.Assert(formatter._deserializerProvider != null);
Contract.Assert(formatter._payloadKinds != null);
Contract.Assert(request != null);
// Parameter 1: formatter
// Execept for the other two parameters, this constructor is a copy constructor, and we need to copy
// everything on the other instance.
// Parameter 1A: Copy this class's private fields.
_serializerProvider = formatter._serializerProvider;
_model = formatter._model;
_deserializerProvider = formatter._deserializerProvider;
_payloadKinds = formatter._payloadKinds;
// Parameter 1B: Copy the base class's properties.
foreach (MediaTypeMapping mediaTypeMapping in formatter.MediaTypeMappings)
{
// MediaTypeMapping doesn't support clone, and its public surface area is immutable anyway.
MediaTypeMappings.Add(mediaTypeMapping);
}
RequiredMemberSelector = formatter.RequiredMemberSelector;
foreach (Encoding supportedEncoding in formatter.SupportedEncodings)
{
// Encoding's public surface area is mutable, so clone (and use separate instances) to prevent changes
// to one instance from affecting the other.
SupportedEncodings.Add((Encoding)supportedEncoding.Clone());
}
foreach (MediaTypeHeaderValue supportedMediaType in formatter.SupportedMediaTypes)
{
// MediaTypeHeaderValue's public surface area is mutable, so clone (and use separate instances) to
// prevent changes to one instance from affecting the other.
SupportedMediaTypes.Add((MediaTypeHeaderValue)((ICloneable)supportedMediaType).Clone());
}
// Parameter 2: version
_version = version;
// Parameter 3: request
_request = request;
}
private ODataDeserializer GetDeserializer(Type type, ODataPath path, IEdmModel model,
ODataDeserializerProvider deserializerProvider, out IEdmTypeReference expectedPayloadType)
{
expectedPayloadType = GetExpectedPayloadType(type, path, model);
// Get the deserializer using the CLR type first from the deserializer provider.
ODataDeserializer deserializer = deserializerProvider.GetODataDeserializer(model, type, Request);
if (deserializer == null && expectedPayloadType != null)
{
// we are in typeless mode, get the deserializer using the edm type from the path.
deserializer = deserializerProvider.GetEdmTypeDeserializer(expectedPayloadType);
}
return(deserializer);
}
/// <summary>
/// Gets an <see cref="ODataDeserializer"/> for the given type.
/// The proxy provider will get the real provider to return the serializer.
/// </summary>
/// <param name="model">The EDM model.</param>
/// <param name="type">The CLR type.</param>
/// <param name="request">The request being deserialized.</param>
/// <returns>An <see cref="ODataDeserializer"/> that can deserialize the given type.</returns>
public override ODataDeserializer GetODataDeserializer(IEdmModel model, Type type, HttpRequestMessage request)
{
this.api = request.GetApiInstance();
if (this.api != null)
{
ODataDeserializerProvider provider = api.Context.GetApiService <ODataDeserializerProvider>();
if (provider != null)
{
return(provider.GetODataDeserializer(model, type, request));
}
}
// In case user uses his own controller or NonFound error for request
return(DefaultRestierDeserializerProvider.SingletonInstance.GetODataDeserializer(model, type, request));
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataMediaTypeFormatter"/> class.
/// </summary>
/// <param name="formatter">The <see cref="ODataMediaTypeFormatter"/> to copy settings from.</param>
/// <param name="version">The OData version that this formatter supports.</param>
/// <param name="request">The <see cref="HttpRequestMessage"/> for the per-request formatter instance.</param>
/// <remarks>This is a copy constructor to be used in <see cref="GetPerRequestFormatterInstance"/>.</remarks>
internal ODataMediaTypeFormatter(ODataMediaTypeFormatter formatter, ODataVersion version, HttpRequestMessage request)
: base(formatter)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
Contract.Assert(formatter._serializerProvider != null);
Contract.Assert(formatter._deserializerProvider != null);
Contract.Assert(formatter._payloadKinds != null);
// Parameter 1: formatter
// Execept for the other two parameters, this constructor is a copy constructor, and we need to copy
// everything on the other instance.
// Copy this class's private fields and internal properties.
_serializerProvider = formatter._serializerProvider;
_deserializerProvider = formatter._deserializerProvider;
_payloadKinds = formatter._payloadKinds;
// Parameter 2: version
_version = version;
// Parameter 3: request
Request = request;
if (_serializerProvider.GetType() == typeof(ODataSerializerProviderProxy))
{
_serializerProvider = new ODataSerializerProviderProxy
{
RequestContainer = request.GetRequestContainer()
};
}
if (_deserializerProvider.GetType() == typeof(ODataDeserializerProviderProxy))
{
_deserializerProvider = new ODataDeserializerProviderProxy
{
RequestContainer = request.GetRequestContainer()
};
}
BaseAddressFactory = formatter.BaseAddressFactory;
}
/// <summary>
/// Convert an OData value into a CLR object.
/// </summary>
/// <param name="graph">The given object.</param>
/// <param name="edmTypeReference">The EDM type of the given object.</param>
/// <param name="clrType">The CLR type of the given object.</param>
/// <param name="parameterName">The parameter name of the given object.</param>
/// <param name="readContext">The <see cref="ODataDeserializerContext"/> use to convert.</param>
/// <param name="requestContainer">The dependency injection container for the request.</param>
/// <returns>The converted object.</returns>
public static object Convert(object graph, IEdmTypeReference edmTypeReference,
Type clrType, string parameterName, ODataDeserializerContext readContext,
IServiceProvider requestContainer)
{
if (graph == null || graph is ODataNullValue)
{
return(null);
}
// collection of primitive, enum
ODataCollectionValue collectionValue = graph as ODataCollectionValue;
if (collectionValue != null)
{
return(ConvertCollection(collectionValue, edmTypeReference, clrType, parameterName, readContext,
requestContainer));
}
// enum value
ODataEnumValue enumValue = graph as ODataEnumValue;
if (enumValue != null)
{
IEdmEnumTypeReference edmEnumType = edmTypeReference.AsEnum();
Contract.Assert(edmEnumType != null);
ODataDeserializerProvider deserializerProvider =
requestContainer.GetRequiredService <ODataDeserializerProvider>();
ODataEnumDeserializer deserializer =
(ODataEnumDeserializer)deserializerProvider.GetEdmTypeDeserializer(edmEnumType);
return(deserializer.ReadInline(enumValue, edmEnumType, readContext));
}
// primitive value
if (edmTypeReference.IsPrimitive())
{
ConstantNode node = graph as ConstantNode;
return(EdmPrimitiveHelper.ConvertPrimitiveValue(node != null ? node.Value : graph, clrType, readContext.TimeZone));
}
// Resource, ResourceSet, Entity Reference or collection of entity reference
return(ConvertResourceOrResourceSet(graph, edmTypeReference, readContext));
}
private ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider,
ODataSerializerProvider serializerProvider,
IEnumerable <ODataPayloadKind> payloadKinds,
ODataVersion version,
HttpRequestMessage request)
{
Contract.Assert(deserializerProvider != null);
Contract.Assert(deserializerProvider.EdmModel != null);
Contract.Assert(serializerProvider != null);
Contract.Assert(payloadKinds != null);
_deserializerProvider = deserializerProvider;
_model = deserializerProvider.EdmModel;
_serializerProvider = serializerProvider;
_payloadKinds = payloadKinds;
_version = version;
_request = request;
}
public void ApplyProperty_FailWithCaseInsensitiveMatchesAndDisabledCaseSensitiveRequestPropertyBinding()
{
const string expectedErrorMessage = "The property 'proPerty1' does not exist on type 'namespace.name'. Make sure to only use property names that are defined by the type.";
// Arrange
ODataProperty property = new ODataProperty {
Name = "proPerty1", Value = "Value1"
};
EdmEntityType entityType = new EdmEntityType("namespace", "name");
entityType.AddStructuralProperty("Property1", EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(typeof(string)));
entityType.AddKeys(entityType.AddStructuralProperty("Key1",
EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(typeof(string))));
EdmEntityTypeReference entityTypeReference = new EdmEntityTypeReference(entityType, isNullable: false);
ODataDeserializerProvider provider = ODataDeserializerProviderFactory.Create();
#if NETCORE
IRouteBuilder builder = RoutingConfigurationFactory.CreateWithDisabledCaseInsensitiveRequestPropertyBinding();
HttpRequest request = RequestFactory.Create(builder);
#else
HttpConfiguration configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData");
configuration.SetCompatibilityOptions(CompatibilityOptions.DisableCaseInsensitiveRequestPropertyBinding);
HttpRequestMessage request = RequestFactory.Create(configuration);
#endif
ODataDeserializerContext context = new ODataDeserializerContext
{
Model = new EdmModel(),
Request = request
};
// Act
var exception = Assert.Throws <ODataException>(() =>
DeserializationHelpers.ApplyProperty(
property,
entityTypeReference,
resource: null,
provider,
context));
// Assert
Assert.Equal(expectedErrorMessage, exception.Message);
}
public void ReadInline_Calls_ReadFeed()
{
// Arrange
ODataDeserializerProvider deserializerProvider = _deserializerProvider;
Mock <ODataResourceSetDeserializer> deserializer = new Mock <ODataResourceSetDeserializer>(deserializerProvider);
ODataResourceSetWrapper feedWrapper = new ODataResourceSetWrapper(new ODataResourceSet());
ODataDeserializerContext readContext = new ODataDeserializerContext();
IEnumerable expectedResult = new object[0];
deserializer.CallBase = true;
deserializer.Setup(f => f.ReadResourceSet(feedWrapper, _customerType, readContext)).Returns(expectedResult).Verifiable();
// Act
var result = deserializer.Object.ReadInline(feedWrapper, _customersType, readContext);
// Assert
deserializer.Verify();
Assert.Same(expectedResult, result);
}
public void ApplyProperty_PassesWithCaseInsensitivePropertyName()
{
// Arrange
ODataProperty property = new ODataProperty {
Name = "keY1", Value = "Value1"
};
EdmEntityType entityType = new EdmEntityType("namespace", "name");
entityType.AddKeys(entityType.AddStructuralProperty("Key1",
EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(typeof(string))));
EdmEntityTypeReference entityTypeReference = new EdmEntityTypeReference(entityType, isNullable: false);
ODataDeserializerProvider provider = ODataDeserializerProviderFactory.Create();
var resource = new Mock <IDelta>(MockBehavior.Strict);
Type propertyType = typeof(string);
resource.Setup(r => r.TryGetPropertyType("Key1", out propertyType)).Returns(true).Verifiable();
resource.Setup(r => r.TrySetPropertyValue("Key1", "Value1")).Returns(true).Verifiable();
#if NETCORE
IRouteBuilder builder = RoutingConfigurationFactory.Create();
HttpRequest request = RequestFactory.Create(builder);
#else
HttpConfiguration configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData");
HttpRequestMessage request = RequestFactory.Create(configuration);
#endif
ODataDeserializerContext context = new ODataDeserializerContext
{
Model = new EdmModel(),
Request = request
};
// Act
DeserializationHelpers.ApplyProperty(property, entityTypeReference, resource.Object, provider,
context);
// Assert
resource.Verify();
}
public EnableNestedPathsTest()
{
_deserializerProvider = ODataDeserializerProviderFactory.Create();
_resourceSetDeserializer = new ODataResourceSetDeserializer(_deserializerProvider);
_resourceDeserializer = new ODataResourceDeserializer(_deserializerProvider);
_primitiveDeserializer = new ODataPrimitiveDeserializer();
ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <EnableNestedPathsCustomer>("EnableNestedPathsCustomers");
builder.EntitySet <EnableNestedPathsProduct>("EnableNestedPathsProducts");
builder.Singleton <EnableNestedPathsCustomer>("EnableNestedPathsTopCustomer");
builder.EntityType <EnableNestedPathsVipCustomer>();
builder.EntityType <EnableNestedPathsVipCustomer>()
.Function("GetMostPurchasedProduct")
.ReturnsFromEntitySet <EnableNestedPathsProduct>("EnableNestedPathsProduct");
builder.EntityType <EnableNestedPathsProduct>()
.Collection
.Action("SetDiscountRate");
_model = builder.GetEdmModel();
Type[] controllers = new Type[] {
typeof(EnableNestedPathsCustomersController),
typeof(EnableNestedPathsProductsController),
typeof(EnableNestedPathsTopCustomerController)
};
_server = TestServerFactory.Create(controllers, (config) =>
{
config.MapODataServiceRoute("odata", "odata", _model);
config.Count().OrderBy().Filter().Expand().MaxTop(null).Select();
});
_client = TestServerFactory.CreateClient(_server);
_db = new EnableNestedPathsDatabase();
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataMediaTypeFormatter"/> class.
/// </summary>
/// <param name="deserializerProvider">The <see cref="ODataDeserializerProvider"/> to use.</param>
/// <param name="serializerProvider">The <see cref="ODataSerializerProvider"/> to use.</param>
/// <param name="payloadKinds">The kind of payloads this formatter supports.</param>
public ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider, ODataSerializerProvider serializerProvider,
IEnumerable <ODataPayloadKind> payloadKinds)
{
if (deserializerProvider == null)
{
throw Error.ArgumentNull("deserializerProvider");
}
if (serializerProvider == null)
{
throw Error.ArgumentNull("serializerProvider");
}
if (payloadKinds == null)
{
throw Error.ArgumentNull("payloadKinds");
}
_deserializerProvider = deserializerProvider;
_serializerProvider = serializerProvider;
_payloadKinds = payloadKinds;
// Maxing out the received message size as we depend on the hosting layer to enforce this limit.
MessageWriterSettings = new ODataMessageWriterSettings
{
Indent = true,
DisableMessageStreamDisposal = true,
MessageQuotas = new ODataMessageQuotas {
MaxReceivedMessageSize = Int64.MaxValue
},
AutoComputePayloadMetadataInJson = true,
};
MessageReaderSettings = new ODataMessageReaderSettings
{
DisableMessageStreamDisposal = true,
MessageQuotas = new ODataMessageQuotas {
MaxReceivedMessageSize = Int64.MaxValue
},
};
_version = HttpRequestMessageProperties.DefaultODataVersion;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataMediaTypeFormatter"/> class.
/// </summary>
/// <param name="deserializerProvider">The <see cref="ODataDeserializerProvider"/> to use.</param>
/// <param name="serializerProvider">The <see cref="ODataSerializerProvider"/> to use.</param>
/// <param name="payloadKinds">The kind of payloads this formatter supports.</param>
public ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider, ODataSerializerProvider serializerProvider,
IEnumerable <ODataPayloadKind> payloadKinds)
{
if (deserializerProvider == null)
{
throw Error.ArgumentNull("deserializerProvider");
}
if (serializerProvider == null)
{
throw Error.ArgumentNull("serializerProvider");
}
if (payloadKinds == null)
{
throw Error.ArgumentNull("payloadKinds");
}
_deserializerProvider = deserializerProvider;
_serializerProvider = serializerProvider;
_payloadKinds = payloadKinds;
_version = HttpRequestMessageProperties.DefaultODataVersion;
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
bool isDynamicProperty = false;
string propertyName = property.Name;
if (edmProperty != null)
{
/*
* Закомментировано, потому что это является ошибкой Microsoft. Нельзя использовать
* имена свойств DataObject в присвоениях значений свойств в EdmEntityObject.
* propertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, readContext.Model);
*/
}
else
{
IEdmStructuredType structuredType = resourceType.StructuredDefinition();
isDynamicProperty = structuredType != null && structuredType.IsOpen;
}
// dynamic properties have null values
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null;
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext,
out propertyKind);
if (isDynamicProperty)
{
SetDynamicProperty(resource, resourceType, propertyKind, propertyName, value, propertyType,
readContext);
}
else
{
SetDeclaredProperty(resource, propertyKind, propertyName, value, edmProperty, readContext);
}
}
/// <inheritdoc/>
public override bool CanReadType(Type type)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (Request != null)
{
ODataDeserializerProvider deserializerProvider = Request.GetRequestContainer()
.GetRequiredService <ODataDeserializerProvider>();
return(ODataInputFormatterHelper.CanReadType(
type,
Request.GetModel(),
Request.ODataProperties().Path,
_payloadKinds,
(objectType) => deserializerProvider.GetEdmTypeDeserializer(objectType),
(objectType) => deserializerProvider.GetODataDeserializer(objectType, Request)));
}
return(false);
}
/// <inheritdoc/>
public override bool CanRead(InputFormatterContext context)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
HttpRequest request = context.HttpContext.Request;
if (request == null)
{
throw Error.InvalidOperation(SRResources.ReadFromStreamAsyncMustHaveRequest);
}
// Ignore non-OData requests.
if (request.ODataFeature().Path == null)
{
return(false);
}
Type type = context.ModelType;
if (type == null)
{
throw Error.ArgumentNull("type");
}
ODataDeserializerProvider deserializerProvider = request.GetRequestContainer().GetRequiredService <ODataDeserializerProvider>();
return(ODataInputFormatterHelper.CanReadType(
type,
request.GetModel(),
request.ODataFeature().Path,
_payloadKinds,
(objectType) => deserializerProvider.GetEdmTypeDeserializer(objectType),
(objectType) => deserializerProvider.GetODataDeserializer(objectType, request)));
}
private static object ConvertResource(ODataMessageReader oDataMessageReader, IEdmTypeReference edmTypeReference,
ODataDeserializerContext readContext)
{
EdmEntitySet tempEntitySet = null;
if (edmTypeReference.IsEntity())
{
IEdmEntityTypeReference entityType = edmTypeReference.AsEntity();
tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp",
entityType.EntityDefinition());
}
// TODO: Sam xu, can we use the parameter-less overload
ODataReader resourceReader = oDataMessageReader.CreateODataUriParameterResourceReader(tempEntitySet,
edmTypeReference.ToStructuredType());
object item = resourceReader.ReadResourceOrResourceSet();
ODataResourceWrapper topLevelResource = item as ODataResourceWrapper;
Contract.Assert(topLevelResource != null);
ODataDeserializerProvider deserializerProvider = readContext.Request.GetDeserializerProvider();
ODataResourceDeserializer entityDeserializer =
(ODataResourceDeserializer)deserializerProvider.GetEdmTypeDeserializer(edmTypeReference);
object value = entityDeserializer.ReadInline(topLevelResource, edmTypeReference, readContext);
if (edmTypeReference.IsEntity())
{
IEdmEntityTypeReference entityType = edmTypeReference.AsEntity();
return(CovertResourceId(value, topLevelResource.Resource, entityType, readContext));
}
return(value);
}
internal ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider,
ODataSerializerProvider serializerProvider,
IEnumerable <ODataPayloadKind> payloadKinds,
ODataVersion version,
HttpRequestMessage request)
{
Contract.Assert(deserializerProvider != null);
Contract.Assert(serializerProvider != null);
Contract.Assert(payloadKinds != null);
_deserializerProvider = deserializerProvider;
_serializerProvider = serializerProvider;
_payloadKinds = payloadKinds;
_version = version;
_request = request;
// Maxing out the received message size as we depend on the hosting layer to enforce this limit.
MessageReaderQuotas = new ODataMessageQuotas {
MaxReceivedMessageSize = Int64.MaxValue
};
MessageWriterQuotas = new ODataMessageQuotas {
MaxReceivedMessageSize = Int64.MaxValue
};
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
Type type = context.ModelType;
if (type == null)
{
throw Error.ArgumentNull("type");
}
HttpRequest request = context.HttpContext.Request;
if (request == null)
{
throw Error.InvalidOperation(SRResources.ReadFromStreamAsyncMustHaveRequest);
}
// If content length is 0 then return default value for this type
RequestHeaders contentHeaders = request.GetTypedHeaders();
object defaultValue = GetDefaultValueForType(type);
if (contentHeaders == null || contentHeaders.ContentLength == 0)
{
return(InputFormatterResult.Success(defaultValue));
}
try
{
Func <ODataDeserializerContext> getODataDeserializerContext = () =>
{
return(new ODataDeserializerContext
{
Request = request,
});
};
Action <Exception> logErrorAction = (ex) =>
{
ILogger logger = context.HttpContext.RequestServices.GetService <ILogger>();
if (logger == null)
{
throw ex;
}
logger.LogError(ex, String.Empty);
};
List <IDisposable> toDispose = new List <IDisposable>();
ODataDeserializerProvider deserializerProvider = request.GetRequestContainer().GetRequiredService <ODataDeserializerProvider>();
object result = await ODataInputFormatterHelper.ReadFromStreamAsync(
type,
defaultValue,
request.GetModel(),
GetBaseAddressInternal(request),
new WebApiRequestMessage(request),
() => ODataMessageWrapperHelper.Create(new StreamWrapper(request.Body), request.Headers, request.GetODataContentIdMapping(), request.GetRequestContainer()),
(objectType) => deserializerProvider.GetEdmTypeDeserializer(objectType),
(objectType) => deserializerProvider.GetODataDeserializer(objectType, request),
getODataDeserializerContext,
(disposable) => toDispose.Add(disposable),
logErrorAction);
foreach (IDisposable obj in toDispose)
{
obj.Dispose();
}
return(InputFormatterResult.Success(result));
}
catch (Exception ex)
{
context.ModelState.AddModelError(context.ModelName, ex, context.Metadata);
return(InputFormatterResult.Failure());
}
}
internal static object ConvertValue(object oDataValue, ref IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider,
ODataDeserializerContext readContext, out EdmTypeKind typeKind)
{
if (oDataValue == null)
{
typeKind = EdmTypeKind.None;
return(null);
}
ODataComplexValue complexValue = oDataValue as ODataComplexValue;
if (complexValue != null)
{
typeKind = EdmTypeKind.Complex;
return(ConvertComplexValue(complexValue, ref propertyType, deserializerProvider, readContext));
}
ODataEnumValue enumValue = oDataValue as ODataEnumValue;
if (enumValue != null)
{
typeKind = EdmTypeKind.Enum;
return(ConvertEnumValue(enumValue, ref propertyType, deserializerProvider, readContext));
}
ODataCollectionValue collection = oDataValue as ODataCollectionValue;
if (collection != null)
{
typeKind = EdmTypeKind.Collection;
return(ConvertCollectionValue(collection, ref propertyType, deserializerProvider, readContext));
}
typeKind = EdmTypeKind.Primitive;
return(oDataValue);
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (readStream == null)
{
throw Error.ArgumentNull("readStream");
}
if (Request == null)
{
throw Error.InvalidOperation(SRResources.ReadFromStreamAsyncMustHaveRequest);
}
object defaultValue = GetDefaultValueForType(type);
// If content length is 0 then return default value for this type
HttpContentHeaders contentHeaders = (content == null) ? null : content.Headers;
if (contentHeaders == null || contentHeaders.ContentLength == 0)
{
return(Task.FromResult(defaultValue));
}
try
{
Func <ODataDeserializerContext> getODataDeserializerContext = () =>
{
return(new ODataDeserializerContext
{
Request = Request,
});
};
Action <Exception> logErrorAction = (ex) =>
{
if (formatterLogger == null)
{
throw ex;
}
formatterLogger.LogError(String.Empty, ex);
};
ODataDeserializerProvider deserializerProvider = Request.GetRequestContainer()
.GetRequiredService <ODataDeserializerProvider>();
return(Task.FromResult(ODataInputFormatterHelper.ReadFromStream(
type,
defaultValue,
Request.GetModel(),
GetBaseAddressInternal(Request),
new WebApiRequestMessage(Request),
() => ODataMessageWrapperHelper.Create(readStream, contentHeaders, Request.GetODataContentIdMapping(), Request.GetRequestContainer()),
(objectType) => deserializerProvider.GetEdmTypeDeserializer(objectType),
(objectType) => deserializerProvider.GetODataDeserializer(objectType, Request),
getODataDeserializerContext,
(disposable) => Request.RegisterForDispose(disposable),
logErrorAction)));
}
catch (Exception ex)
{
return(TaskHelpers.FromError <object>(ex));
}
}
private static object ConvertCollectionValue(ODataCollectionValue collection,
ref IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider,
ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType;
if (propertyType == null)
{
// dynamic collection property
Contract.Assert(!String.IsNullOrEmpty(collection.TypeName),
"ODataLib should have verified that dynamic collection value has a type name " +
"since we provided metadata.");
string elementTypeName = GetCollectionElementTypeName(collection.TypeName, isNested: false);
IEdmModel model = readContext.Model;
IEdmSchemaType elementType = model.FindType(elementTypeName);
Contract.Assert(elementType != null);
collectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(elementType.ToEdmTypeReference(isNullable: false)));
propertyType = collectionType;
}
else
{
collectionType = propertyType as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null, "The type for collection must be a IEdmCollectionType.");
}
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(collectionType);
return(deserializer.ReadInline(collection, collectionType, readContext));
}
public ReferenceLinkParsingEntityDeserializer(ODataDeserializerProvider deserializerProvider)
: base(deserializerProvider)
{
}
