/// <summary>
/// Constructor.
/// </summary>
/// <param name="parameterWriter">The writer to wrap.</param>
/// <param name="testConfiguration">The test configuration to use.</param>
public ODataParameterWriterTestWrapper(ODataParameterWriter parameterWriter, WriterTestConfiguration testConfiguration)
{
ExceptionUtilities.CheckArgumentNotNull(parameterWriter, "parameterWriter");
ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
this.parameterWriter = parameterWriter;
this.testConfiguration = testConfiguration;
}
/// <summary>
/// Writes collection value in body operation parameter.
/// </summary>
/// <param name="parameterWriter">The odata parameter writer.</param>
/// <param name="operationParameter">The operation parameter.</param>
/// <param name="edmCollectionType">The edm collection type.</param>
private void WriteCollectionValueInBodyOperationParameter(ODataParameterWriter parameterWriter, BodyOperationParameter operationParameter, IEdmCollectionType edmCollectionType)
{
ClientEdmModel model = this.requestInfo.Model;
if (edmCollectionType.ElementType.TypeKind() == EdmTypeKind.Entity)
{
ODataWriter feedWriter = parameterWriter.CreateFeedWriter(operationParameter.Name);
feedWriter.WriteStart(new ODataFeed());
IEnumerator enumerator = ((ICollection)operationParameter.Value).GetEnumerator();
while (enumerator.MoveNext())
{
Object collectionItem = enumerator.Current;
if (collectionItem == null)
{
throw new NotSupportedException(Strings.Serializer_NullCollectionParamterItemValue(operationParameter.Name));
}
IEdmType edmItemType = model.GetOrCreateEdmType(collectionItem.GetType());
Debug.Assert(edmItemType != null, "edmItemType != null");
if (edmItemType.TypeKind != EdmTypeKind.Entity)
{
throw new NotSupportedException(Strings.Serializer_InvalidCollectionParamterItemType(operationParameter.Name, edmItemType.TypeKind));
}
Debug.Assert(model.GetClientTypeAnnotation(edmItemType).ElementType != null, "edmItemType.GetClientTypeAnnotation().ElementType != null");
ODataEntry entry = this.CreateODataEntryFromEntityOperationParameter(model.GetClientTypeAnnotation(edmItemType), collectionItem);
Debug.Assert(entry != null, "entry != null");
feedWriter.WriteStart(entry);
feedWriter.WriteEnd();
}
feedWriter.WriteEnd();
feedWriter.Flush();
}
else
{
ODataCollectionWriter collectionWriter = parameterWriter.CreateCollectionWriter(operationParameter.Name);
ODataCollectionStart odataCollectionStart = new ODataCollectionStart();
collectionWriter.WriteStart(odataCollectionStart);
IEnumerator enumerator = ((ICollection)operationParameter.Value).GetEnumerator();
while (enumerator.MoveNext())
{
Object collectionItem = enumerator.Current;
if (collectionItem == null)
{
collectionWriter.WriteItem(null);
continue;
}
IEdmType edmItemType = model.GetOrCreateEdmType(collectionItem.GetType());
Debug.Assert(edmItemType != null, "edmItemType != null");
switch (edmItemType.TypeKind)
{
case EdmTypeKind.Complex:
{
Debug.Assert(model.GetClientTypeAnnotation(edmItemType).ElementType != null, "edmItemType.GetClientTypeAnnotation().ElementType != null");
ODataComplexValue complexValue = this.propertyConverter.CreateODataComplexValue(model.GetClientTypeAnnotation(edmItemType).ElementType, collectionItem, null /*propertyName*/, false /*isCollectionItem*/, null /*visitedComplexTypeObjects*/);
Debug.Assert(complexValue != null, "complexValue != null");
collectionWriter.WriteItem(complexValue);
break;
}
case EdmTypeKind.Primitive:
{
object primitiveItemValue = ODataPropertyConverter.ConvertPrimitiveValueToRecognizedODataType(collectionItem, collectionItem.GetType());
collectionWriter.WriteItem(primitiveItemValue);
break;
}
case EdmTypeKind.Enum:
{
ODataEnumValue enumTmp = this.propertyConverter.CreateODataEnumValue(model.GetClientTypeAnnotation(edmItemType).ElementType, collectionItem, false);
collectionWriter.WriteItem(enumTmp);
break;
}
default:
// EdmTypeKind.Entity
// EdmTypeKind.Row
// EdmTypeKind.EntityReference
throw new NotSupportedException(Strings.Serializer_InvalidCollectionParamterItemType(operationParameter.Name, edmItemType.TypeKind));
}
}
collectionWriter.WriteEnd();
collectionWriter.Flush();
}
}
private async Task WriteOperationParameterAsync(ODataParameterWriter parameterWriter, IEdmOperationParameter operationParameter, string paramName, object paramValue)
{
switch (operationParameter.Type.Definition.TypeKind)
{
case EdmTypeKind.Primitive:
case EdmTypeKind.Enum:
case EdmTypeKind.Complex:
await parameterWriter.WriteValueAsync(paramName, paramValue);
break;
case EdmTypeKind.Entity:
var entryWriter = await parameterWriter.CreateEntryWriterAsync(paramName);
var entry = CreateODataEntry(operationParameter.Type.Definition.FullTypeName(), paramValue.ToDictionary());
await entryWriter.WriteStartAsync(entry);
await entryWriter.WriteEndAsync();
break;
case EdmTypeKind.Collection:
var collectionType = operationParameter.Type.Definition as IEdmCollectionType;
var elementType = collectionType.ElementType;
if (elementType.Definition.TypeKind == EdmTypeKind.Entity)
{
var feedWriter = await parameterWriter.CreateFeedWriterAsync(paramName);
var feed = new ODataFeed();
await feedWriter.WriteStartAsync(feed);
foreach (var item in paramValue as IEnumerable)
{
var feedEntry = CreateODataEntry(elementType.Definition.FullTypeName(), item.ToDictionary());
await feedWriter.WriteStartAsync(feedEntry);
await feedWriter.WriteEndAsync();
}
await feedWriter.WriteEndAsync();
}
else
{
var collectionWriter = await parameterWriter.CreateCollectionWriterAsync(paramName);
await collectionWriter.WriteStartAsync(new ODataCollectionStart());
foreach (var item in paramValue as IEnumerable)
{
await collectionWriter.WriteItemAsync(item);
}
await collectionWriter.WriteEndAsync();
}
break;
default:
throw new NotSupportedException(string.Format("Unable to write action parameter of a type {0}", operationParameter.Type.Definition.TypeKind));
}
}
