public void InvokeActionBoundedToSingleton()
{
foreach (var mimeType in mimeTypes)
{
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Company/Microsoft.Test.OData.Services.ODataWCFService.IncreaseRevenue", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
requestMessage.Method = "POST";
var oldProperty = this.QueryProperty("Company/Revenue", mimeType);
Int64 oldValue = (Int64)oldProperty.Value;
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = ServiceBaseUri
};
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter(null);
odataWriter.WriteStart();
odataWriter.WriteValue("IncreaseValue", 20000);
odataWriter.WriteEnd();
}
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
ODataProperty property = this.QueryProperty("Company/Revenue", mimeType);
Assert.AreEqual((Int64)(oldValue + 20000), property.Value);
}
}
}
public void InvokeActionWithUintParameterAndReturnType()
{
var writerSettings = new ODataMessageWriterSettings();
writerSettings.BaseUri = ServiceBaseUri;
var readerSettings = new ODataMessageReaderSettings();
readerSettings.BaseUri = ServiceBaseUri;
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "Products(11)/microsoft.odata.sampleService.models.typedefinition.ExtendLifeTime"));
requestMessage.SetHeader("Content-Type", MimeTypes.ApplicationJson);
requestMessage.SetHeader("Accept", MimeTypes.ApplicationJson);
requestMessage.Method = "POST";
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter((IEdmOperation)null);
odataWriter.WriteStart();
odataWriter.WriteValue("seconds", 1000u);
odataWriter.WriteEnd();
}
// send the http request
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var property = messageReader.ReadProperty();
Assert.IsNotNull(property);
Assert.AreEqual(4600ul, property.Value);
}
}
public void BoundActionInReferencedModel()
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "VehicleGPSSet('VehicleKey6')/Microsoft.OData.SampleService.Models.ModelRefDemo.GPS.ResetVehicleSpeed", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
requestMessage.Method = "POST";
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
PayloadBaseUri = ServiceBaseUri
};
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter(null);
odataWriter.WriteStart();
odataWriter.WriteValue("targetValue", 80);
odataWriter.WriteEnd();
}
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(204, responseMessage.StatusCode);
var actual = (this.QueryEntityItem("VehicleGPSSet('VehicleKey6')") as ODataEntry).Properties.Single(p => p.Name == "VehicleSpeed").Value;
Assert.AreEqual((double)80, actual);
}
protected override async Task <Stream> WriteActionContentAsync(string method, string commandText, string actionName, IDictionary <string, object> parameters)
{
#if SILVERLIGHT
IODataRequestMessage
#else
IODataRequestMessageAsync
#endif
message = IsBatch
? await CreateBatchOperationMessageAsync(method, null, null, commandText, true)
.ConfigureAwait(false) : new ODataRequestMessage();
using (var messageWriter = new ODataMessageWriter(message, GetWriterSettings(ODataFormat.Json), _model))
{
var action = _model.SchemaElements
.Where(x => x.SchemaElementKind == EdmSchemaElementKind.EntityContainer)
.SelectMany(x => (x as IEdmEntityContainer).FunctionImports())
.BestMatch(x => x.Name, actionName, _session.Pluralizer);
#if SILVERLIGHT
var parameterWriter = messageWriter.CreateODataParameterWriter(action);
parameterWriter.WriteStart();
#else
var parameterWriter = await messageWriter.CreateODataParameterWriterAsync(action).ConfigureAwait(false);
await parameterWriter.WriteStartAsync().ConfigureAwait(false);
#endif
foreach (var parameter in parameters)
{
var operationParameter = action.Parameters.BestMatch(x => x.Name, parameter.Key, _session.Pluralizer);
if (operationParameter == null)
{
throw new UnresolvableObjectException(parameter.Key, string.Format("Parameter [{0}] not found for action [{1}]", parameter.Key, actionName));
}
#if SILVERLIGHT
WriteOperationParameter(parameterWriter, operationParameter, parameter.Key, parameter.Value);
#else
await WriteOperationParameterAsync(parameterWriter, operationParameter, parameter.Key, parameter.Value).ConfigureAwait(false);
#endif
}
#if SILVERLIGHT
parameterWriter.WriteEnd();
#else
await parameterWriter.WriteEndAsync().ConfigureAwait(false);
#endif
if (IsBatch)
{
return(null);
}
#if SILVERLIGHT
return(message.GetStream());
#else
return(await message.GetStreamAsync().ConfigureAwait(false));
#endif
}
}
public void UnBoundActionForEntryInReferencedModel()
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "ResetVehicleSpeedToValue", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
requestMessage.Method = "POST";
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = ServiceBaseUri
};
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter(null);
odataWriter.WriteStart();
odataWriter.WriteValue("targetValue", 80);
odataWriter.WriteEnd();
}
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
var actual = (this.QueryEntityItem("VehicleGPSSetInGPS('VehicleGPSSetInGPSKey2')") as ODataResource).Properties.Single(p => p.Name == "VehicleSpeed").Value;
Assert.Equal((double)80, actual);
}
protected override async Task <Stream> WriteActionContentAsync(string method, string commandText, string actionName, IDictionary <string, object> parameters)
{
#if SILVERLIGHT
IODataRequestMessage
#else
IODataRequestMessageAsync
#endif
message = IsBatch
? await CreateBatchOperationMessageAsync(method, null, null, commandText, false)
: new ODataRequestMessage();
using (var messageWriter = new ODataMessageWriter(message, GetWriterSettings(), _model))
{
var action = _model.SchemaElements
.Where(x => x.SchemaElementKind == EdmSchemaElementKind.EntityContainer)
.SelectMany(x => (x as IEdmEntityContainer).FunctionImports())
.BestMatch(x => x.Name, actionName, _session.Pluralizer);
var parameterWriter = messageWriter.CreateODataParameterWriter(action);
parameterWriter.WriteStart();
foreach (var parameter in parameters)
{
var actionParameter = action.Parameters.BestMatch(x => x.Name, parameter.Key, _session.Pluralizer);
if (actionParameter == null)
{
throw new UnresolvableObjectException(parameter.Key, string.Format("Parameter [{0}] not found for action [{1}]", parameter.Key, actionName));
}
if (actionParameter.Type.Definition.TypeKind == EdmTypeKind.Collection)
{
var collectionWriter = parameterWriter.CreateCollectionWriter(parameter.Key);
collectionWriter.WriteStart(new ODataCollectionStart());
foreach (var item in parameter.Value as IEnumerable)
{
collectionWriter.WriteItem(item);
}
collectionWriter.WriteEnd();
}
else
{
parameterWriter.WriteValue(parameter.Key, parameter.Value);
}
}
parameterWriter.WriteEnd();
if (IsBatch)
{
return(null);
}
#if SILVERLIGHT
return(message.GetStream());
#else
return(await message.GetStreamAsync());
#endif
}
}
public void ActionTakeDateAndTimeAsParameter()
{
var writerSettings = new ODataMessageWriterSettings();
writerSettings.BaseUri = ServiceBaseUri;
var readerSettings = new ODataMessageReaderSettings();
readerSettings.BaseUri = ServiceBaseUri;
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "Orders(7)/Microsoft.Test.OData.Services.ODataWCFService.ChangeShipTimeAndDate"));
requestMessage.SetHeader("Content-Type", mimeType);
requestMessage.SetHeader("Accept", mimeType);
requestMessage.Method = "POST";
Date newDate = Date.MinValue;
TimeOfDay newTime = TimeOfDay.MinValue;
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter((IEdmOperation)null);
odataWriter.WriteStart();
odataWriter.WriteValue("date", newDate);
odataWriter.WriteValue("time", newTime);
odataWriter.WriteEnd();
}
// send the http request
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
ODataResource entry = reader.Item as ODataResource;
if (entry != null)
{
Assert.Equal(Date.MinValue, entry.Properties.Single(p => p.Name == "ShipDate").Value);
Assert.Equal(TimeOfDay.MinValue, entry.Properties.Single(p => p.Name == "ShipTime").Value);
}
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
public void InvokeActionWithEnumParameterAndReturnType()
{
var writerSettings = new ODataMessageWriterSettings();
writerSettings.PayloadBaseUri = ServiceBaseUri;
var readerSettings = new ODataMessageReaderSettings();
readerSettings.BaseUri = ServiceBaseUri;
foreach (var mimeType in mimeTypes)
{
if (mimeType == MimeTypes.ApplicationAtomXml)
{
continue;
}
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "Products(5)/Microsoft.Test.OData.Services.ODataWCFService.AddAccessRight"));
requestMessage.SetHeader("Content-Type", mimeType);
requestMessage.SetHeader("Accept", "*/*");
requestMessage.Method = "POST";
ODataEnumValue accessRight = new ODataEnumValue("Read,Execute", NameSpacePrefix + "AccessLevel");
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter((IEdmOperation)null);
odataWriter.WriteStart();
odataWriter.WriteValue("accessRight", accessRight);
odataWriter.WriteEnd();
}
// send the http request
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var userAccessPropertyValue = messageReader.ReadProperty();
ODataEnumValue enumValue = userAccessPropertyValue.Value as ODataEnumValue;
Assert.AreEqual("Read, Execute", enumValue.Value);
}
}
}
}
protected override async Task <Stream> WriteActionContentAsync(string actionName, IDictionary <string, object> parameters)
{
var message = new ODataRequestMessage();
using (var messageWriter = new ODataMessageWriter(message, GetWriterSettings(), _model))
{
var action = _model.SchemaElements
.Where(x => x.SchemaElementKind == EdmSchemaElementKind.EntityContainer)
.SelectMany(x => (x as IEdmEntityContainer).FunctionImports())
.BestMatch(x => x.Name, actionName, _session.Pluralizer);
var parameterWriter = messageWriter.CreateODataParameterWriter(action);
parameterWriter.WriteStart();
foreach (var parameter in parameters)
{
if (!(parameter.Value is string) && parameter.Value is IEnumerable)
{
var collectionWriter = parameterWriter.CreateCollectionWriter(parameter.Key);
collectionWriter.WriteStart(new ODataCollectionStart());
foreach (var item in parameter.Value as IEnumerable)
{
collectionWriter.WriteItem(item);
}
collectionWriter.WriteEnd();
}
else
{
parameterWriter.WriteValue(parameter.Key, parameter.Value);
}
}
parameterWriter.WriteEnd();
return(await message.GetStreamAsync());
}
}
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));
}
}
/// <summary>
/// Writes the body operation parameters associated with a ServiceAction. For each BodyOperationParameter:
/// 1. calls ODataPropertyConverter to convert CLR object into ODataValue/primitive values.
/// 2. then calls ODataParameterWriter to write the ODataValue/primitive values.
/// </summary>
/// <param name="operationParameters">The list of operation parameters to write.</param>
/// <param name="requestMessage">The OData request message used to write the operation parameters.</param>
internal void WriteBodyOperationParameters(List <BodyOperationParameter> operationParameters, ODataRequestMessageWrapper requestMessage)
{
Debug.Assert(requestMessage != null, "requestMessage != null");
Debug.Assert(operationParameters != null, "operationParameters != null");
Debug.Assert(operationParameters.Any(), "operationParameters.Any()");
using (ODataMessageWriter messageWriter = Serializer.CreateMessageWriter(requestMessage, this.requestInfo, true /*isParameterPayload*/))
{
ODataParameterWriter parameterWriter = messageWriter.CreateODataParameterWriter((IEdmOperation)null);
parameterWriter.WriteStart();
foreach (OperationParameter operationParameter in operationParameters)
{
if (operationParameter.Value == null)
{
parameterWriter.WriteValue(operationParameter.Name, operationParameter.Value);
}
else
{
ClientEdmModel model = this.requestInfo.Model;
IEdmType edmType = model.GetOrCreateEdmType(operationParameter.Value.GetType());
Debug.Assert(edmType != null, "edmType != null");
switch (edmType.TypeKind)
{
case EdmTypeKind.Collection:
{
// TODO: just call ODataPropertyConverter.CreateODataCollection()
IEnumerator enumerator = ((ICollection)operationParameter.Value).GetEnumerator();
ODataCollectionWriter collectionWriter = parameterWriter.CreateCollectionWriter(operationParameter.Name);
ODataCollectionStart odataCollectionStart = new ODataCollectionStart();
collectionWriter.WriteStart(odataCollectionStart);
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");
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();
break;
}
case EdmTypeKind.Complex:
{
Debug.Assert(model.GetClientTypeAnnotation(edmType).ElementType != null, "model.GetClientTypeAnnotation(edmType).ElementType != null");
ODataComplexValue complexValue = this.propertyConverter.CreateODataComplexValue(
model.GetClientTypeAnnotation(edmType).ElementType,
operationParameter.Value,
null /*propertyName*/,
false /*isCollectionItemType*/,
null /*visitedComplexTypeObjects*/);
Debug.Assert(complexValue != null, "complexValue != null");
parameterWriter.WriteValue(operationParameter.Name, complexValue);
break;
}
case EdmTypeKind.Primitive:
object primitiveValue = ODataPropertyConverter.ConvertPrimitiveValueToRecognizedODataType(operationParameter.Value, operationParameter.Value.GetType());
parameterWriter.WriteValue(operationParameter.Name, primitiveValue);
break;
case EdmTypeKind.Enum:
ODataEnumValue tmp = this.propertyConverter.CreateODataEnumValue(
model.GetClientTypeAnnotation(edmType).ElementType,
operationParameter.Value,
false);
parameterWriter.WriteValue(operationParameter.Name, tmp);
break;
default:
// EdmTypeKind.Entity
// EdmTypeKind.Row
// EdmTypeKind.EntityReference
throw new NotSupportedException(Strings.Serializer_InvalidParameterType(operationParameter.Name, edmType.TypeKind));
}
} // else
} // foreach
parameterWriter.WriteEnd();
parameterWriter.Flush();
}
}
protected override async Task<Stream> WriteActionContentAsync(string actionName, IDictionary<string, object> parameters)
{
var message = new ODataRequestMessage();
using (var messageWriter = new ODataMessageWriter(message, GetWriterSettings(), _model))
{
var action = _model.SchemaElements
.Where(x => x.SchemaElementKind == EdmSchemaElementKind.EntityContainer)
.SelectMany(x => (x as IEdmEntityContainer).FunctionImports())
.BestMatch(x => x.Name, actionName, _session.Pluralizer);
var parameterWriter = messageWriter.CreateODataParameterWriter(action);
parameterWriter.WriteStart();
foreach (var parameter in parameters)
{
var actionParameter = action.Parameters.BestMatch(x => x.Name, parameter.Key, _session.Pluralizer);
if (actionParameter == null)
throw new UnresolvableObjectException(parameter.Key, string.Format("Parameter [{0}] not found for action [{1}]", parameter.Key, actionName));
if (actionParameter.Type.Definition.TypeKind == EdmTypeKind.Collection)
{
var collectionWriter = parameterWriter.CreateCollectionWriter(parameter.Key);
collectionWriter.WriteStart(new ODataCollectionStart());
foreach (var item in parameter.Value as IEnumerable)
{
collectionWriter.WriteItem(item);
}
collectionWriter.WriteEnd();
}
else
{
parameterWriter.WriteValue(parameter.Key, parameter.Value);
}
}
parameterWriter.WriteEnd();
return await message.GetStreamAsync();
}
}
internal void WriteBodyOperationParameters(List <BodyOperationParameter> operationParameters, ODataRequestMessageWrapper requestMessage)
{
using (ODataMessageWriter writer = CreateMessageWriter(requestMessage, this.requestInfo))
{
ODataParameterWriter writer2 = writer.CreateODataParameterWriter(null);
writer2.WriteStart();
foreach (OperationParameter parameter in operationParameters)
{
IEnumerator enumerator;
ODataCollectionWriter writer3;
object obj2;
if (parameter.Value == null)
{
writer2.WriteValue(parameter.Name, parameter.Value);
continue;
}
ClientEdmModel model = ClientEdmModel.GetModel(this.requestInfo.MaxProtocolVersion);
IEdmType orCreateEdmType = model.GetOrCreateEdmType(parameter.Value.GetType());
switch (orCreateEdmType.TypeKind)
{
case EdmTypeKind.Primitive:
{
writer2.WriteValue(parameter.Name, parameter.Value);
continue;
}
case EdmTypeKind.Complex:
{
ODataComplexValue parameterValue = this.CreateODataComplexValue(model.GetClientTypeAnnotation(orCreateEdmType).ElementType, parameter.Value, null, false, null);
writer2.WriteValue(parameter.Name, parameterValue);
continue;
}
case EdmTypeKind.Collection:
{
enumerator = ((ICollection)parameter.Value).GetEnumerator();
writer3 = writer2.CreateCollectionWriter(parameter.Name);
ODataCollectionStart collectionStart = new ODataCollectionStart();
writer3.WriteStart(collectionStart);
goto Label_016D;
}
default:
throw new NotSupportedException(System.Data.Services.Client.Strings.Serializer_InvalidParameterType(parameter.Name, orCreateEdmType.TypeKind));
}
Label_00D3:
obj2 = enumerator.Current;
if (obj2 == null)
{
throw new NotSupportedException(System.Data.Services.Client.Strings.Serializer_NullCollectionParamterItemValue(parameter.Name));
}
IEdmType edmType = model.GetOrCreateEdmType(obj2.GetType());
switch (edmType.TypeKind)
{
case EdmTypeKind.Primitive:
writer3.WriteItem(obj2);
break;
case EdmTypeKind.Complex:
{
ODataComplexValue item = this.CreateODataComplexValue(model.GetClientTypeAnnotation(edmType).ElementType, obj2, null, false, null);
writer3.WriteItem(item);
break;
}
default:
throw new NotSupportedException(System.Data.Services.Client.Strings.Serializer_InvalidCollectionParamterItemType(parameter.Name, edmType.TypeKind));
}
Label_016D:
if (enumerator.MoveNext())
{
goto Label_00D3;
}
writer3.WriteEnd();
writer3.Flush();
}
writer2.WriteEnd();
writer2.Flush();
}
}
public void InvokeAvroAction()
{
ODataEntry product1 = new ODataEntry
{
TypeName = "Microsoft.Test.OData.Services.PluggableFormat.Product",
Properties = new[]
{
new ODataProperty {
Name = "Id", Value = 1
},
new ODataProperty {
Name = "Name", Value = "Peach"
},
new ODataProperty
{
Name = "Info",
Value = new ODataComplexValue()
{
TypeName = "Microsoft.Test.OData.Services.PluggableFormat.ProductInfo",
Properties = new []
{
new ODataProperty {
Name = "Site", Value = "G1"
},
new ODataProperty {
Name = "Serial", Value = 1024L
},
}
}
},
},
};
IEdmModel model = new PluggableFormatService(null).Format.LoadServiceModel();
IEdmOperation action = model.FindDeclaredOperations("Microsoft.Test.OData.Services.PluggableFormat.AddProduct").Single();
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Products/Microsoft.Test.OData.Services.PluggableFormat.AddProduct", UriKind.Absolute));
requestMessage.Method = "POST";
using (var mw = new ODataMessageWriter(requestMessage, GetAvroWriterSettings(), model))
{
var pw = mw.CreateODataParameterWriter(action);
pw.WriteStart();
var ew = pw.CreateEntryWriter("Value");
{
ew.WriteStart(product1);
ew.WriteEnd();
ew.Flush();
}
pw.WriteValue("Override", true);
pw.WriteEnd();
pw.Flush();
}
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(204, responseMessage.StatusCode);
requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Products(1)", UriKind.Absolute));
requestMessage.SetHeader("Accept", "avro/binary");
responseMessage = requestMessage.GetResponse();
ODataEntry entry = null;
using (var messageReader = new ODataMessageReader(responseMessage, GetAvroReaderSettings(), Model))
{
var reader = messageReader.CreateODataEntryReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entry = reader.Item as ODataEntry;
}
}
}
Assert.IsNotNull(entry);
Assert.IsTrue(TestHelper.EntryEqual(product1, entry));
}
#pragma warning restore 1998
protected override async Task<Stream> WriteActionContentAsync(string actionName, IDictionary<string, object> parameters)
{
var message = new ODataRequestMessage();
using (var messageWriter = new ODataMessageWriter(message, GetWriterSettings(), _model))
{
var action = _model.SchemaElements
.Where(x => x.SchemaElementKind == EdmSchemaElementKind.EntityContainer)
.SelectMany(x => (x as IEdmEntityContainer).FunctionImports())
.BestMatch(x => x.Name, actionName, _session.Pluralizer);
var parameterWriter = messageWriter.CreateODataParameterWriter(action);
parameterWriter.WriteStart();
foreach (var parameter in parameters)
{
if (!(parameter.Value is string) && parameter.Value is IEnumerable)
{
var collectionWriter = parameterWriter.CreateCollectionWriter(parameter.Key);
collectionWriter.WriteStart(new ODataCollectionStart());
foreach (var item in parameter.Value as IEnumerable)
{
collectionWriter.WriteItem(item);
}
collectionWriter.WriteEnd();
}
else
{
parameterWriter.WriteValue(parameter.Key, parameter.Value);
}
}
parameterWriter.WriteEnd();
return await message.GetStreamAsync();
}
}
/// <summary>
/// Writes the body operation parameters associated with a ServiceAction. For each BodyOperationParameter:
/// 1. calls ODataPropertyConverter to convert CLR object into ODataValue/primitive values.
/// 2. then calls ODataParameterWriter to write the ODataValue/primitive values.
/// </summary>
/// <param name="operationParameters">The list of operation parameters to write.</param>
/// <param name="requestMessage">The OData request message used to write the operation parameters.</param>
internal void WriteBodyOperationParameters(List <BodyOperationParameter> operationParameters, ODataRequestMessageWrapper requestMessage)
{
Debug.Assert(requestMessage != null, "requestMessage != null");
Debug.Assert(operationParameters != null, "operationParameters != null");
Debug.Assert(operationParameters.Any(), "operationParameters.Any()");
using (ODataMessageWriter messageWriter = Serializer.CreateMessageWriter(requestMessage, this.requestInfo, true /*isParameterPayload*/))
{
ODataParameterWriter parameterWriter = messageWriter.CreateODataParameterWriter(null);
parameterWriter.WriteStart();
foreach (BodyOperationParameter operationParameter in operationParameters)
{
if (operationParameter.Value == null)
{
parameterWriter.WriteValue(operationParameter.Name, operationParameter.Value);
}
else
{
ClientEdmModel model = this.requestInfo.Model;
IEdmType edmType = model.GetOrCreateEdmType(operationParameter.Value.GetType());
Debug.Assert(edmType != null, "edmType != null");
switch (edmType.TypeKind)
{
case EdmTypeKind.Collection:
{
this.WriteCollectionValueInBodyOperationParameter(parameterWriter, operationParameter, (IEdmCollectionType)edmType);
break;
}
case EdmTypeKind.Complex:
case EdmTypeKind.Entity:
{
Debug.Assert(model.GetClientTypeAnnotation(edmType).ElementType != null, "model.GetClientTypeAnnotation(edmType).ElementType != null");
ODataResourceWrapper entry = this.CreateODataResourceFromEntityOperationParameter(model.GetClientTypeAnnotation(edmType), operationParameter.Value);
Debug.Assert(entry != null, "entry != null");
var entryWriter = parameterWriter.CreateResourceWriter(operationParameter.Name);
ODataWriterHelper.WriteResource(entryWriter, entry);
break;
}
case EdmTypeKind.Primitive:
object primitiveValue = ODataPropertyConverter.ConvertPrimitiveValueToRecognizedODataType(operationParameter.Value, operationParameter.Value.GetType());
parameterWriter.WriteValue(operationParameter.Name, primitiveValue);
break;
case EdmTypeKind.Enum:
ODataEnumValue tmp = this.propertyConverter.CreateODataEnumValue(
model.GetClientTypeAnnotation(edmType).ElementType,
operationParameter.Value,
false);
parameterWriter.WriteValue(operationParameter.Name, tmp);
break;
default:
// EdmTypeKind.Row
// EdmTypeKind.EntityReference
throw new NotSupportedException(Strings.Serializer_InvalidParameterType(operationParameter.Name, edmType.TypeKind));
}
} // else
} // foreach
parameterWriter.WriteEnd();
parameterWriter.Flush();
}
}
protected override async Task<Stream> WriteActionContentAsync(string method, string commandText, string actionName, IDictionary<string, object> parameters)
{
#if SILVERLIGHT
IODataRequestMessage
#else
IODataRequestMessageAsync
#endif
message = IsBatch
? await CreateBatchOperationMessageAsync(method, null, null, commandText, false)
: new ODataRequestMessage();
using (var messageWriter = new ODataMessageWriter(message, GetWriterSettings(), _model))
{
var action = _model.SchemaElements
.Where(x => x.SchemaElementKind == EdmSchemaElementKind.EntityContainer)
.SelectMany(x => (x as IEdmEntityContainer).FunctionImports())
.BestMatch(x => x.Name, actionName, _session.Pluralizer);
#if SILVERLIGHT
var parameterWriter = messageWriter.CreateODataParameterWriter(action);
parameterWriter.WriteStart();
#else
var parameterWriter = await messageWriter.CreateODataParameterWriterAsync(action);
await parameterWriter.WriteStartAsync();
#endif
foreach (var parameter in parameters)
{
var operationParameter = action.Parameters.BestMatch(x => x.Name, parameter.Key, _session.Pluralizer);
if (operationParameter == null)
throw new UnresolvableObjectException(parameter.Key, string.Format("Parameter [{0}] not found for action [{1}]", parameter.Key, actionName));
#if SILVERLIGHT
WriteOperationParameter(parameterWriter, operationParameter, parameter.Key, parameter.Value);
#else
await WriteOperationParameterAsync(parameterWriter, operationParameter, parameter.Key, parameter.Value);
#endif
}
#if SILVERLIGHT
parameterWriter.WriteEnd();
#else
await parameterWriter.WriteEndAsync();
#endif
if (IsBatch)
return null;
#if SILVERLIGHT
return message.GetStream();
#else
return await message.GetStreamAsync();
#endif
}
}
