/// <summary>
/// Reads the Action parameters payload and returns the WCF DS value representation of each parameter.
/// </summary>
/// <param name="segmentInfo">Info about the parameters payload to read.</param>
/// <returns>The WCF DS representation of the parameters read.</returns>
protected override object Read(SegmentInfo segmentInfo)
{
Debug.Assert(segmentInfo != null, "segmentInfo != null");
Debug.Assert(
segmentInfo.TargetSource == RequestTargetSource.ServiceOperation &&
segmentInfo.Operation != null &&
segmentInfo.Operation.Kind == OperationKind.Action,
"The ParametersDeserializer should only be called for an Action segment.");
IEdmOperation operation = this.GetOperation(segmentInfo.Operation);
ODataParameterReader reader = this.MessageReader.CreateODataParameterReader(operation);
AssertReaderFormatIsExpected(this.MessageReader, ODataFormat.Json);
Dictionary <string, object> parameters = new Dictionary <string, object>(EqualityComparer <string> .Default);
ResourceType parameterResourceType;
object convertedParameterValue;
while (reader.Read())
{
if (reader.State == ODataParameterReaderState.Completed)
{
break;
}
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterResourceType = segmentInfo.Operation.Parameters.Single(p => p.Name == reader.Name).ParameterType;
convertedParameterValue = this.ConvertValue(reader.Value, ref parameterResourceType);
break;
case ODataParameterReaderState.Collection:
ODataCollectionReader collectionReader = reader.CreateCollectionReader();
parameterResourceType = segmentInfo.Operation.Parameters.Single(p => p.Name == reader.Name).ParameterType;
Debug.Assert(parameterResourceType.ResourceTypeKind == ResourceTypeKind.Collection, "parameterResourceType.ResourceTypeKind == ResourceTypeKind.Collection");
convertedParameterValue = this.ConvertValue(ParameterDeserializer.ReadCollectionParameterValue(collectionReader), ref parameterResourceType);
break;
default:
Debug.Assert(false, "Unreachable code path in Read().");
throw new InvalidOperationException(Microsoft.OData.Service.Strings.DataServiceException_GeneralError);
}
parameters.Add(reader.Name, convertedParameterValue);
}
// ODataLib allows nullable parameters to be missing from the payload. When that happens, we use null for the parameter value.
foreach (IEdmOperationParameter parameterMetadata in operation.Parameters.Skip(operation.IsBound ? 1 : 0))
{
object value;
if (!parameters.TryGetValue(parameterMetadata.Name, out value))
{
Debug.Assert(parameterMetadata.Type.IsNullable, "ODataParameterReader should only allows nullable parameters to be missing from the payload.");
parameters.Add(parameterMetadata.Name, null);
}
}
return(parameters);
}
/// <summary>
/// Reads Parameter names and values provided by a client in a POST request to invoke a particular Action.
/// </summary>
/// <param name="messageReader">Reader used to read all OData payloads (entries, feeds, metadata documents, service documents, etc.).</param>
/// <param name="action">Represents an EDM operation.</param>
/// <param name="readContext">
/// Encapsulates the state and settings that get passed to System.Web.OData.Formatter.Deserialization.ODataDeserializer from the System.Web.OData.Formatter.ODataMediaTypeFormatter.
/// </param>
/// <returns>ActionPayload holds the Parameter names and values provided by a client in a POST request to invoke a particular Action.</returns>
private ODataActionParameters ReadParams(ODataMessageReader messageReader, IEdmOperation action, ODataDeserializerContext readContext)
{
// Create the correct resource type;
ODataActionParameters payload = new ODataActionParameters();
try
{
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmOperationParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = DefaultODataDeserializerProvider.Instance.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataCollectionValue value = ReadCollection(reader.CreateCollectionReader());
ODataCollectionDeserializer collectionDeserializer = DefaultODataDeserializerProvider.Instance.GetEdmTypeDeserializer(collectionType) as ODataCollectionDeserializer;
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
break;
default:
break;
}
}
}
catch (Exception exception)
{
DynamicLogger.Instance.WriteLoggerLogError("ReadParams", exception);
throw;
}
return(payload);
}
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));
}
}
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
// Create the correct resource type;
ODataActionParameters payload = new ODataActionParameters();
IEdmFunctionImport action = GetFunctionImport(readContext);
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmFunctionParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
payload[parameterName] = Convert(reader.Value, parameter.Type, readContext);
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
payload[parameterName] = Convert(reader.CreateCollectionReader(), collectionType, readContext);
break;
default:
break;
}
}
return(payload);
}
private object CreateSubReader(ODataParameterReader parameterReader, CreateReaderMethods createMethod)
{
switch (createMethod)
{
case CreateReaderMethods.CreateResourceReader:
return(parameterReader.CreateResourceReader());
case CreateReaderMethods.CreateResourceSetReader:
return(parameterReader.CreateResourceSetReader());
case CreateReaderMethods.CreateCollectionReader:
return(parameterReader.CreateCollectionReader());
default:
throw new NotSupportedException("Unsupported create method: " + createMethod);
}
}
protected override object Read(System.Data.Services.SegmentInfo segmentInfo)
{
Func <OperationParameter, bool> predicate = null;
Func <OperationParameter, bool> func2 = null;
IEdmFunctionImport functionImport = base.GetFunctionImport(segmentInfo.Operation);
ODataParameterReader reader = base.MessageReader.CreateODataParameterReader(functionImport);
Dictionary <string, object> dictionary = new Dictionary <string, object>(EqualityComparer <string> .Default);
while (reader.Read())
{
ResourceType parameterType;
object obj2;
switch (reader.State)
{
case ODataParameterReaderState.Value:
if (predicate == null)
{
predicate = p => p.Name == reader.Name;
}
parameterType = segmentInfo.Operation.Parameters.Single <OperationParameter>(predicate).ParameterType;
obj2 = base.ConvertValue(reader.Value, ref parameterType);
break;
case ODataParameterReaderState.Collection:
{
ODataCollectionReader collectionReader = reader.CreateCollectionReader();
if (func2 == null)
{
func2 = p => p.Name == reader.Name;
}
parameterType = segmentInfo.Operation.Parameters.Single <OperationParameter>(func2).ParameterType;
obj2 = base.ConvertValue(ReadCollectionParameterValue(collectionReader), ref parameterType);
break;
}
case ODataParameterReaderState.Completed:
return(dictionary);
default:
throw new InvalidOperationException(System.Data.Services.Strings.DataServiceException_GeneralError);
}
dictionary.Add(reader.Name, obj2);
}
return(dictionary);
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmFunctionImport action = GetFunctionImport(readContext);
// Create the correct resource type;
Dictionary <string, object> payload;
if (type == typeof(ODataActionParameters))
{
payload = new ODataActionParameters();
}
else
{
payload = new ODataUntypedActionParameters(action);
}
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmFunctionParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataCollectionValue value = ODataCollectionDeserializer.ReadCollection(reader.CreateCollectionReader());
ODataCollectionDeserializer collectionDeserializer = DeserializerProvider.GetEdmTypeDeserializer(collectionType) as ODataCollectionDeserializer;
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
break;
default:
break;
}
}
return(payload);
}
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmAction action = GetAction(readContext);
Contract.Assert(action != null);
// Create the correct resource type;
Dictionary <string, object> payload;
if (type == typeof(ODataActionParameters))
{
payload = new ODataActionParameters();
}
else
{
payload = new ODataUntypedActionParameters(action);
}
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmOperationParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataCollectionValue value = ODataCollectionDeserializer.ReadCollection(reader.CreateCollectionReader());
ODataCollectionDeserializer collectionDeserializer = (ODataCollectionDeserializer)DeserializerProvider.GetEdmTypeDeserializer(collectionType);
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
break;
case ODataParameterReaderState.Resource:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
Contract.Assert(parameter.Type.IsStructured());
ODataReader resourceReader = reader.CreateResourceReader();
object item = resourceReader.ReadResourceOrResourceSet();
ODataResourceDeserializer resourceDeserializer = (ODataResourceDeserializer)DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = resourceDeserializer.ReadInline(item, parameter.Type, readContext);
break;
case ODataParameterReaderState.ResourceSet:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference resourceSetType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(resourceSetType != null);
ODataReader resourceSetReader = reader.CreateResourceSetReader();
object feed = resourceSetReader.ReadResourceOrResourceSet();
ODataResourceSetDeserializer resourceSetDeserializer = (ODataResourceSetDeserializer)DeserializerProvider.GetEdmTypeDeserializer(resourceSetType);
object result = resourceSetDeserializer.ReadInline(feed, resourceSetType, readContext);
IEdmTypeReference elementTypeReference = resourceSetType.ElementType();
Contract.Assert(elementTypeReference.IsStructured());
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
if (readContext.IsUntyped)
{
payload[parameterName] = enumerable.ConvertToEdmObject(resourceSetType);
}
else
{
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference, readContext.Model);
IEnumerable castedResult =
_castMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new[] { result }) as IEnumerable;
payload[parameterName] = castedResult;
}
}
break;
}
}
return(payload);
}
private static async Task ReadCollectionAsync(IEdmAction action, ODataParameterReader reader, ODataDeserializerContext readContext, ODataDeserializerProvider deserializerProvider, Dictionary <string, object> payload)
{
string parameterName;
IEdmCollectionTypeReference collectionType = GetCollectionParameterType(action, reader, out parameterName);
ODataCollectionValue value = await ODataCollectionDeserializer.ReadCollectionAsync(reader.CreateCollectionReader());
ODataCollectionDeserializer collectionDeserializer = (ODataCollectionDeserializer)deserializerProvider.GetEdmTypeDeserializer(collectionType);
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
}
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmAction action = GetAction(readContext);
Contract.Assert(action != null);
// Create the correct resource type;
Dictionary <string, object> payload;
if (type == typeof(ODataActionParameters))
{
payload = new ODataActionParameters();
}
else
{
payload = new ODataUntypedActionParameters(action);
}
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmOperationParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataCollectionValue value = ReadCollection(reader.CreateCollectionReader());
ODataCollectionDeserializer collectionDeserializer = (ODataCollectionDeserializer)DeserializerProvider.GetEdmTypeDeserializer(collectionType);
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
break;
case ODataParameterReaderState.Entry:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmEntityTypeReference entityTypeReference = parameter.Type as IEdmEntityTypeReference;
Contract.Assert(entityTypeReference != null);
ODataReader entryReader = reader.CreateEntryReader();
object item = ODataEntityDeserializer.ReadEntryOrFeed(entryReader);
var savedProps = new List <ODataProperty>();
if (item is ODataEntryWithNavigationLinks)
{
var obj = CreateDataObject(readContext.Model as DataObjectEdmModel, entityTypeReference, item as ODataEntryWithNavigationLinks, out Type objType);
payload[parameterName] = obj;
break;
}
ODataEntityDeserializer entityDeserializer = (ODataEntityDeserializer)DeserializerProvider.GetEdmTypeDeserializer(entityTypeReference);
payload[parameterName] = entityDeserializer.ReadInline(item, entityTypeReference, readContext);
break;
case ODataParameterReaderState.Feed:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference feedType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(feedType != null);
ODataReader feedReader = reader.CreateFeedReader();
object feed = ODataEntityDeserializer.ReadEntryOrFeed(feedReader);
IEnumerable enumerable;
ODataFeedWithEntries odataFeedWithEntries = feed as ODataFeedWithEntries;
if (odataFeedWithEntries != null)
{
List <DataObject> list = new List <DataObject>();
Type objType = null;
foreach (ODataEntryWithNavigationLinks entry in odataFeedWithEntries.Entries)
{
list.Add(CreateDataObject(readContext.Model as DataObjectEdmModel, feedType.ElementType() as IEdmEntityTypeReference, entry, out objType));
}
IEnumerable castedResult =
_castMethodInfo.MakeGenericMethod(objType)
.Invoke(null, new[] { list }) as IEnumerable;
payload[parameterName] = castedResult;
break;
}
ODataFeedDeserializer feedDeserializer = (ODataFeedDeserializer)DeserializerProvider.GetEdmTypeDeserializer(feedType);
object result = feedDeserializer.ReadInline(feed, feedType, readContext);
IEdmTypeReference elementTypeReference = feedType.ElementType();
Contract.Assert(elementTypeReference.IsEntity());
enumerable = result as IEnumerable;
if (enumerable != null)
{
var isUntypedProp = readContext.GetType().GetProperty("IsUntyped", BindingFlags.NonPublic | BindingFlags.Instance);
bool isUntyped = (bool)isUntypedProp.GetValue(readContext, null);
if (isUntyped)
{
EdmEntityObjectCollection entityCollection = new EdmEntityObjectCollection(feedType);
foreach (EdmEntityObject entityObject in enumerable)
{
entityCollection.Add(entityObject);
}
payload[parameterName] = entityCollection;
}
else
{
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference, readContext.Model);
IEnumerable castedResult =
_castMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new[] { result }) as IEnumerable;
payload[parameterName] = castedResult;
}
}
break;
}
}
return(payload);
}