public async override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (!content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var Parts = await content.ReadAsMultipartAsync();
var FileContent = Parts.Contents.First(x =>
SupportedMediaTypes.Contains(x.Headers.ContentType));
var DataString = "";
foreach (var Part in Parts.Contents.Where(x => x.Headers.ContentDisposition.DispositionType == "form-data"
&& x.Headers.ContentDisposition.Name == "\"data\""))
{
var Data = await Part.ReadAsStringAsync();
DataString = Data;
}
string FileName = FileContent.Headers.ContentDisposition.FileName;
string MediaType = FileContent.Headers.ContentType.MediaType;
using (var Imgstream = await FileContent.ReadAsStreamAsync())
{
return new GenericContent { ContentType = MediaType, Body = ReadToEnd(Imgstream) };
}
}
public override object ReadFromStream(Type type, Stream stream, HttpContent content,
IFormatterLogger formatterLogger) {
Encoding selectedEncoding = SelectCharacterEncoding(content.Headers);
using (var reader = new StreamReader(stream, selectedEncoding)) {
return reader.ReadToEnd();
}
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
var taskCompletionSource = new TaskCompletionSource<object>();
try
{
BsonReader reader = new BsonReader(readStream);
if (typeof(IEnumerable).IsAssignableFrom(type)) reader.ReadRootValueAsArray = true;
using (reader)
{
var jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
var output = jsonSerializer.Deserialize(reader, type);
if (formatterLogger != null)
{
jsonSerializer.Error += (sender, e) =>
{
Exception exception = e.ErrorContext.Error;
formatterLogger.LogError(e.ErrorContext.Path, exception.Message);
e.ErrorContext.Handled = true;
};
}
taskCompletionSource.SetResult(output);
}
}
catch (Exception ex)
{
if (formatterLogger == null) throw;
formatterLogger.LogError(String.Empty, ex.Message);
taskCompletionSource.SetResult(GetDefaultValueForType(type));
}
return taskCompletionSource.Task;
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
return Task.Factory.StartNew<object>( () =>
{
try
{
var body = base.ReadBodyFromStream(readStream, content);
if (type == typeof(Bundle))
{
if (XmlSignatureHelper.IsSigned(body))
{
if (!XmlSignatureHelper.VerifySignature(body))
throw Error.BadRequest("Digital signature in body failed verification");
}
}
if (typeof(Resource).IsAssignableFrom(type))
{
Resource resource = FhirParser.ParseResourceFromXml(body);
return resource;
}
else
throw Error.Internal("The type {0} expected by the controller can not be deserialized", type.Name);
}
catch (FormatException exc)
{
throw Error.BadRequest("Body parsing failed: " + exc.Message);
}
});
}
private object DeSerialize(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
// If content length is 0 then return default value for this type
if (contentHeaders != null && contentHeaders.ContentLength == 0)
{
return GetDefaultValueForType(type);
}
// Get the character encoding for the content
Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders);
try
{
using (var reader = new StreamReader(readStream, effectiveEncoding, false, 512, true))
{
var deserialize = TypedDeserializers.GetTyped(type);
return deserialize(reader, _jilOptions);
}
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return GetDefaultValueForType(type);
}
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
var task = Task<object>.Factory.StartNew(() =>
{
var ser = JsonNetExtensions.GetJsonSerializer();
using (var sr = new StreamReader(readStream))
{
using (var jreader = new JsonTextReader(sr))
{
ser.Converters.Add(new IsoDateTimeConverter());
return ser.Deserialize(jreader, type);
}
}
/*
var sr = new StreamReader(stream);
var jreader = new JsonTextReader(sr);
var ser = new JsonSerializer();
ser.Converters.Add(new IsoDateTimeConverter());
object val = ser.Deserialize(jreader, type);
return val;*/
});
return task;
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var reader = new StreamReader(readStream);
var deserialize = TypedDeserializers.GetTyped(type);
var result = deserialize(reader, options);
return Task.FromResult(result);
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
return Task.Factory.StartNew(() =>
{
MemoryStream stream = new MemoryStream();
readStream.CopyTo(stream);
IEnumerable<string> xContentHeader;
var success = content.Headers.TryGetValues("X-Content-Type", out xContentHeader);
if (!success)
{
throw Error.BadRequest("POST to binary must provide a Content-Type header");
}
string contentType = xContentHeader.FirstOrDefault();
Binary binary = new Binary();
binary.Content = stream.ToArray();
binary.ContentType = contentType;
//ResourceEntry entry = ResourceEntry.Create(binary);
//entry.Tags = content.Headers.GetFhirTags();
return (object)binary;
});
}
//public JsonFormatter()
//{
// SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/json"));
// SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
//}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var task = new TaskCompletionSource<object>();
using (var ms = new MemoryStream())
{
readStream.CopyTo(ms);
//ms.Seek(0, SeekOrigin.Begin);
//var result = JsonSchemaValidator.Instance().Validate(ms, type);
//if (!string.IsNullOrWhiteSpace(result))
// task.SetResult(result);
//else
{
ms.Seek(0, SeekOrigin.Begin);
using (var reader = new JsonTextReader(new StreamReader(ms)))
{
var serializer = new JsonSerializer();
task.SetResult(serializer.Deserialize(reader, type));
}
}
}
return task.Task;
}
/// <inheritdoc />
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 (type == typeof(DBNull) && content != null && content.Headers != null && content.Headers.ContentLength == 0)
{
// Lower-level Json.Net deserialization can convert null to DBNull.Value. However this formatter treats
// DBNull.Value like null and serializes no content. Json.Net code won't be invoked at all (for read or
// write). Override BaseJsonMediaTypeFormatter.ReadFromStream()'s call to GetDefaultValueForType()
// (which would return null in this case) and instead return expected DBNull.Value. Special case exists
// primarily for parity with JsonMediaTypeFormatter.
return Task.FromResult((object)DBNull.Value);
}
else
{
return base.ReadFromStreamAsync(type, readStream, content, formatterLogger);
}
}
public override async Task<object> ReadFromStreamAsync(Type type, Stream stream,
HttpContent httpContent,
IFormatterLogger iFormatterLogger)
{
MultipartStreamProvider parts = await httpContent.ReadAsMultipartAsync();
IEnumerable<HttpContent> contents = parts.Contents;
HttpContent content = contents.FirstOrDefault();
foreach (HttpContent c in contents ) {
if (SupportedMediaTypes.Contains(c.Headers.ContentType)) {
content = c;
break;
}
}
using (var msgStream = await content.ReadAsStreamAsync())
{
DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(TenMsg));
TenMsg msg = (TenMsg)js.ReadObject(msgStream);
Debug.WriteLine("msgString: " + msgStream.ToString());
int sender = msg.Sender;
int receiver = msg.Receiver;
byte phoneType = msg.PhoneType;
bool isLocked = msg.IsLocked;
DateTime msgTime = msg.MsgTime;
string msgContent = msg.MsgContent;
Debug.WriteLine("Msg Content: " + msg.MsgContent);
return new TenMsg(sender, receiver, phoneType, isLocked, msgTime, msgContent);
}
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
return Task.Factory.StartNew(() =>
{
return (object)null;
});
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var tcs = new TaskCompletionSource<object>();
if (content != null && content.Headers.ContentLength == 0) return null;
try
{
var reader = new BsonReader(readStream);
if (typeof(IEnumerable).IsAssignableFrom(type)) reader.ReadRootValueAsArray = true;
using (reader)
{
var jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
var output = jsonSerializer.Deserialize(reader, type);
tcs.SetResult(output);
}
}
catch (Exception)
{
tcs.SetResult(GetDefaultValueForType(type));
}
return tcs.Task;
}
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
MultipartMemoryStreamProvider multipartMemoryStreamProvider = await content.ReadAsMultipartAsync();
Collection<HttpContent> contents = multipartMemoryStreamProvider.Contents;
ImageSet imageSet = await contents.FirstOrDefault<HttpContent>((HttpContent c) => c.Headers.ContentDisposition.Name.NormalizeName() == "imageset").ReadAsAsync<ImageSet>();
ImageSet images = imageSet;
Collection<HttpContent> httpContents = multipartMemoryStreamProvider.Contents;
List<HttpContent> list = (
from c in httpContents
where c.Headers.ContentDisposition.Name.NormalizeName().Matches("image\\d+")
select c).ToList<HttpContent>();
images.Images = new List<Image>();
foreach (HttpContent httpContent in list)
{
List<Image> images1 = images.Images;
Image image = new Image();
Image image1 = image;
image1.ImageData = await httpContent.ReadAsByteArrayAsync();
image.MimeType = httpContent.Headers.ContentType.MediaType;
image.FileName = httpContent.Headers.ContentDisposition.FileName.NormalizeName();
images1.Add(image);
images1 = null;
image1 = null;
image = null;
}
return images;
}
private async Task<object> Deserialize(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var headers = (content == null) ? null : content.Headers;
if (headers != null && headers.ContentLength == 0L)
{
return MediaTypeFormatter.GetDefaultValueForType(type);
}
object result = null;
try
{
result = DeserializeByJsonSerializer(type, readStream, headers);
}
catch (Exception exception)
{
if (formatterLogger != null)
{
formatterLogger.LogError(string.Empty, exception);
}
result = MediaTypeFormatter.GetDefaultValueForType(type);
}
return result;
}
public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger)
{
var tcs = new TaskCompletionSource<object>();
if (content.Headers != null && content.Headers.ContentLength == 0) return null;
try
{
var serializer = MessagePackSerializer.Get(type, sContext);
object result;
using (var unpacker = Unpacker.Create(stream))
{
unpacker.Read();
result = serializer.UnpackFrom(unpacker);
}
tcs.SetResult(result);
}
catch (Exception e)
{
if (formatterLogger == null) throw;
formatterLogger.LogError(String.Empty, e.Message);
tcs.SetResult(GetDefaultValueForType(type));
}
return tcs.Task;
}
public async override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var imageSet = new ImageSet();
var provider = await content.ReadAsMultipartAsync();
//extract model
var modelContent = provider.Contents.FirstOrDefault(c => c.Headers.ContentDisposition.Name.NormalizeName() == "imageset");
if (modelContent != null)
{
imageSet = await modelContent.ReadAsAsync<ImageSet>();
}
if (!imageSet.Images.Any())
{
//try extract from image content
var fileContents = provider.Contents.Where(c => c.Headers.ContentDisposition.Name.NormalizeName().Matches(@"image\d+")).ToList();
foreach (var fileContent in fileContents)
{
imageSet.Images.Add(new Image
{
FileName = fileContent.Headers.ContentDisposition.FileName.NormalizeName(),
MimeType = fileContent.Headers.ContentType.MediaType,
Side = GetSide(fileContent),
ImageData = await fileContent.ReadAsByteArrayAsync()
});
}
}
return imageSet;
}
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var root = GetRootFieldName(type);
var contentHeaders = content == null ? null : content.Headers;
// If content length is 0 then return default value for this type
if (contentHeaders != null && contentHeaders.ContentLength == 0)
return GetDefaultValueForType(type);
// Get the character encoding for the content
var effectiveEncoding = SelectCharacterEncoding(contentHeaders);
try
{
using (var reader = (new StreamReader(readStream, effectiveEncoding)))
{
var json = reader.ReadToEnd();
var serializer = new EmberJsonSerializer();
var deserialized = serializer.Deserialize(json, root);
return deserialized.ToObject(type);
}
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return GetDefaultValueForType(type);
}
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger, CancellationToken cancellationToken)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (readStream == null)
{
throw new ArgumentNullException("readStream");
}
var completion = new TaskCompletionSource<object>();
if (cancellationToken.IsCancellationRequested)
{
completion.SetCanceled();
}
else
{
try
{
var value = ReadValue(type, readStream, content, formatterLogger);
completion.SetResult(value);
}
catch (Exception ex)
{
completion.SetException(ex);
}
}
return completion.Task;
}
public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, IFormatterLogger formatterLogger)
{
Task<IEnumerable<HttpContent>> readAsMultipartAsync = _httpRequestMessage.Content.ReadAsMultipartAsync();
IEnumerable<HttpContent> httpContents = readAsMultipartAsync.Result;
HttpContent content = httpContents.First(x => SupportedMediaTypes.Contains(x.Headers.ContentType));
string fileName = content.Headers.ContentDisposition.FileName;
string mediaType = content.Headers.ContentType.MediaType;
Task<Stream> readAsStreamAsync = content.ReadAsStreamAsync();
byte[] readFully = readAsStreamAsync.Result.ReadFully();
var taskCompletionSource = new TaskCompletionSource<object>();
taskCompletionSource.SetResult(new ImageMedia(fileName, mediaType, readFully));
return taskCompletionSource.Task;
// var taskCompletionSource = new TaskCompletionSource<object>();
// try
// {
// var memoryStream = new MemoryStream();
// stream.CopyTo(memoryStream);
// var s = System.Text.Encoding.UTF8.GetString(memoryStream.ToArray());
// taskCompletionSource.SetResult(s);
// }
// catch (Exception e)
// {
// taskCompletionSource.SetException(e);
// }
// return taskCompletionSource.Task;
}
public override object ReadFromStream(Type type, Stream stream, HttpContentHeaders contentHeaders, IFormatterLogger formatterLogger)
{
BufferedMediaTypeFormatter innerFormatter = InnerBufferedFormatter;
MediaTypeHeaderValue contentType = contentHeaders == null ? null : contentHeaders.ContentType;
object value = null;
_innerTracer.TraceWriter.TraceBeginEnd(
_innerTracer.Request,
TraceCategories.FormattingCategory,
TraceLevel.Info,
_innerTracer.InnerFormatter.GetType().Name,
OnReadFromStreamMethodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceReadFromStreamMessage,
type.Name,
contentType == null ? SRResources.TraceNoneObjectMessage : contentType.ToString());
},
execute: () =>
{
value = innerFormatter.ReadFromStream(type, stream, contentHeaders, formatterLogger);
},
endTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceReadFromStreamValueMessage,
FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture));
},
errorTrace: null);
return value;
}
public override System.Threading.Tasks.Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger)
{
return new TaskFactory<object>().StartNew(() =>
{
return new StreamReader(stream).ReadToEnd();
});
}
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
using (var streamReader = new StreamReader(readStream))
{
return await streamReader.ReadToEndAsync();
}
}
public override object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) {
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
// If content length is 0 then return default value for this type
if (contentHeaders != null && contentHeaders.ContentLength == null) {
return GetDefaultValueForType(type);
}
try {
using (readStream) {
using (var reader = XmlReader.Create(readStream)) {
var formatter = new Atom10ItemFormatter();
formatter.ReadFrom(reader);
var command = Activator.CreateInstance(type);
((IPublicationCommand)command).ReadSyndicationItem(formatter.Item);
return command;
}
}
}
catch (Exception e) {
if (formatterLogger == null) {
throw;
}
formatterLogger.LogError(String.Empty, e);
return GetDefaultValueForType(type);
}
}
//private readonly ILog Log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
//public XmlFormatter()
//{
// SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/xml"));
// SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/xml"));
//}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
var task = new TaskCompletionSource<object>();
var serializer = new XmlSerializer(type);
using (var ms = new MemoryStream())
{
readStream.CopyTo(ms);
//ms.Seek(0, SeekOrigin.Begin);
//Log.IfDebugFormat("Content Length: {0}", ms.Length);
//Log.IfDebugFormat("Content: {0}", new StreamReader(ms).ReadToEnd());
//var result = XmlSchemaValidator.Instance().Validate(ms, type);
//if (!string.IsNullOrWhiteSpace(result))
//task.SetResult(result);
//else
{
ms.Seek(0, SeekOrigin.Begin);
var obj = serializer.Deserialize(ms);
task.SetResult(obj);
}
}
return task.Task;
}
public ReadFromStreamArgs(Type type, Stream stream, HttpContent content, IFormatterLogger logger)
{
Type = type;
Stream = stream;
Content = content;
Logger = logger;
}
public override Task<object> ReadFromStreamAsync(Type type, System.IO.Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
return Task<object>.Factory.StartNew(() =>
{
var reader = new StreamReader(readStream);
var text = reader.ReadToEnd();
var regex = new Regex("<wav>[a-zA-Z0-9]*.wav</wav>");
var wavLink = regex.Match(text).Value.Replace("<wav>", "").Replace("</wav>", "");
if(string.IsNullOrEmpty(wavLink))
{
wavLink = "{wav}";
}
//<dt>:
regex = new Regex("<dt>:[a-zA-Z0-9 '.s\"\\(\\):]*<");
var def = regex.Match(text).Value.Replace("<dt>:", "").Replace("<", "");
if(string.IsNullOrEmpty(def))
{
def = "{def}";
}
return wavLink + ";" +def;
});
}
public async override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger)
{
try
{
if (!content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = await content.ReadAsMultipartAsync();
var mediacontent = provider.Contents.First(x =>
SupportedMediaTypes.Contains(x.Headers.ContentType));
string fileName = mediacontent.Headers.ContentDisposition.FileName;
string mediaType = mediacontent.Headers.ContentType.MediaType;
var imagebuffer = await mediacontent.ReadAsByteArrayAsync();
return new ImageMediaModels(fileName, mediaType, imagebuffer);
}
catch (Exception Ex)
{
string Err = "Unable to upload the image ";
Log.LogError("{0}, Error: {1}", Err, Ex.Message);
throw;
}
}
public override Task<object> ReadFromStreamAsync(Type type, Stream input, HttpContent content, IFormatterLogger formatterLogger)
{
var reader = new StreamReader(input);
Func<TextReader, Options, object> deserialize = TypedDeserializers.GetTyped(type);
object result = deserialize(reader, _options);
return Task.FromResult(result);
}
public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger logger)
{
var trades = new Trades();
var symbol = _symbol;
using (var reader = new StreamReader(stream))
{
var line = reader.ReadLine();
var seperator = ",".ToCharArray();
while (null != (line = reader.ReadLine()))
{
if (!line.Contains("502 Bad Gateway"))
{
var parts = line.Split(seperator);
var unixtime = parts[0].Parse();
var price = decimal.Parse(parts[1], CultureInfo.InvariantCulture);
var quantity = decimal.Parse(parts[2], CultureInfo.InvariantCulture);
var datetime = Epoch.AddSeconds(unixtime);
trades.Add(symbol, datetime, price, quantity);
}
else throw new Exception("Bad Gateway");
}
}
var tcs = new TaskCompletionSource<object>();
tcs.SetResult(trades);
return tcs.Task;
}
// Perf-sensitive - keeping the async method as small as possible
private async Task ExecuteBindingAsyncCore(ModelMetadataProvider metadataProvider, HttpActionContext actionContext,
HttpParameterDescriptor paramFromBody, Type type, HttpRequestMessage request, IFormatterLogger formatterLogger,
CancellationToken cancellationToken)
{
var model = await ReadContentAsync(request, type, Formatters, formatterLogger, cancellationToken);
if (model == null)
{
model = System.Activator.CreateInstance(type);
}
;
var routeParams = actionContext.ControllerContext.RouteData.Values;
foreach (var key in routeParams.Keys.Where(k => k != "controller"))
{
var prop = type.GetProperty(key, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public);
if (prop == null)
{
continue;
}
var descriptor = TypeDescriptor.GetConverter(prop.PropertyType);
if (descriptor.CanConvertFrom(typeof(string)))
{
prop.SetValue(model, descriptor.ConvertFromString(routeParams[key] as string));
}
}
var queryParams = actionContext.Request.GetQueryNameValuePairs();
foreach (var queryParam in queryParams)
{
var prop = type.GetProperty(queryParam.Key, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public);
if (prop == null)
{
continue;
}
var descriptor = TypeDescriptor.GetConverter(prop.PropertyType);
if (descriptor.CanConvertFrom(typeof(string)))
{
prop.SetValue(model, descriptor.ConvertFromString(queryParam.Value));
}
}
// Set the merged model in the context
SetValue(actionContext, model);
if (BodyModelValidator != null)
{
BodyModelValidator.Validate(model, type, metadataProvider, actionContext, paramFromBody.ParameterName);
}
}
public override object ReadFromStream(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger)
{
if (!typeof(Representation).IsAssignableFrom(type))
{
return(null);
}
var xml = XElement.Load(stream);
return(ReadHalResource(type, xml));
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var task = Task.Factory.StartNew(() =>
{
using (var rdr = new StreamReader(readStream))
{
var json = rdr.ReadToEnd();
JavaScriptSerializer ser = new JavaScriptSerializer();
object result = ser.Deserialize(json, type);
return(result);
}
});
return(task);
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (readStream == null)
{
throw new ArgumentNullException("readStream");
}
// For simple types, defer to base class
if (base.CanReadType(type))
{
return(base.ReadFromStreamAsync(type, readStream, content, formatterLogger));
}
return(base.ReadFromStreamAsync(typeof(FormDataCollection), readStream, content, formatterLogger).Then(
(obj) =>
{
FormDataCollection fd = (FormDataCollection)obj;
try
{
return fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger);
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return GetDefaultValueForType(type);
}
}));
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var taskSource = new TaskCompletionSource <object>();
try
{
var obj = new XmlSerializer(type).Deserialize(readStream);
taskSource.SetResult(obj);
}
catch (Exception e)
{
taskSource.SetException(e);
}
return(taskSource.Task);
}
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
// If content length is 0 then return default value for this type
if (contentHeaders != null && contentHeaders.ContentLength == 0)
{
return(GetDefaultValueForType(type));
}
// Get the character encoding for the content
Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders);
try
{
using (JsonTextReader jsonTextReader = new JsonTextReader(new StreamReader(readStream, effectiveEncoding))
{
CloseInput = false, MaxDepth = _maxDepth
})
{
JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
if (formatterLogger != null)
{
// Error must always be marked as handled
// Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes
jsonSerializer.Error += (sender, e) =>
{
Exception exception = e.ErrorContext.Error;
formatterLogger.LogError(e.ErrorContext.Path, exception);
e.ErrorContext.Handled = true;
};
}
return(jsonSerializer.Deserialize(jsonTextReader, type));
}
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return(GetDefaultValueForType(type));
}
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (readStream == null)
{
throw new ArgumentNullException("readStream");
}
try
{
return(TaskHelpers.FromResult(ReadFromStream(type, readStream, content, formatterLogger)));
}
catch (Exception e)
{
return(TaskHelpers.FromError <object>(e));
}
}
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
object result;
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
// If content length is 0 then return default value for this type
if (contentHeaders == null || contentHeaders.ContentLength == 0)
{
result = GetDefaultValueForType(type);
}
else
{
IEdmModel model = Request.ODataProperties().Model;
if (model == null)
{
throw Error.InvalidOperation(SRResources.RequestMustHaveModel);
}
IEdmTypeReference expectedPayloadType;
ODataDeserializer deserializer = GetDeserializer(type, Request.ODataProperties().Path, model, _deserializerProvider, out expectedPayloadType);
if (deserializer == null)
{
throw Error.Argument("type", SRResources.FormatterReadIsNotSupportedForType, type.FullName, GetType().FullName);
}
try
{
ODataMessageReaderSettings oDataReaderSettings = new ODataMessageReaderSettings(MessageReaderSettings);
oDataReaderSettings.BaseUri = GetBaseAddressInternal(Request);
IODataRequestMessage oDataRequestMessage = new ODataMessageWrapper(readStream, contentHeaders, Request.GetODataContentIdMapping());
ODataMessageReader oDataMessageReader = new ODataMessageReader(oDataRequestMessage, oDataReaderSettings, model);
Request.RegisterForDispose(oDataMessageReader);
ODataPath path = Request.ODataProperties().Path;
ODataDeserializerContext readContext = new ODataDeserializerContext
{
Path = path,
Model = model,
Request = Request,
ResourceType = type,
ResourceEdmType = expectedPayloadType,
RequestContext = Request.GetRequestContext(),
};
result = deserializer.Read(oDataMessageReader, type, readContext);
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
result = GetDefaultValueForType(type);
}
}
return(result);
}
protected virtual Task <object> ReadContentAsync(HttpRequestMessage request, Type type, IEnumerable <MediaTypeFormatter> formatters, IFormatterLogger formatterLogger)
{
return(request.Content.ReadAsAsync(type, formatters, formatterLogger));
}
public override Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger)
{
string value;
using (var reader = new StreamReader(stream))
{
value = reader.ReadToEnd();
}
var tcs = new TaskCompletionSource <object>();
tcs.SetResult(value);
return(tcs.Task);
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
try
{
var body = base.ReadBodyFromStream(readStream, content);
if (type == typeof(Bundle))
{
if (XmlSignatureHelper.IsSigned(body))
{
if (!XmlSignatureHelper.VerifySignature(body))
{
//throw Error.BadRequest("Digital signature in body failed verification");
throw new InterneuronBusinessException((short)HttpStatusCode.BadRequest, "Digital signature in body failed verification");
}
}
}
if (typeof(Resource).IsAssignableFrom(type))
{
Resource resource = _parser.Parse <Resource>(body);
return(System.Threading.Tasks.Task.FromResult <object>(resource));
}
else
{
//throw Error.Internal("The type {0} expected by the controller can not be deserialized", type.Name);
throw new InterneuronBusinessException((short)HttpStatusCode.InternalServerError, $"The type {type.Name} expected by the controller can not be deserialized");
}
}
catch (FormatException exc)
{
//throw Error.BadRequest("Body parsing failed: " + exc.Message);
throw new InterneuronBusinessException(exc, (short)HttpStatusCode.BadRequest, "Body parsing failed: " + exc.Message);
}
}
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);
}
try
{
return(Task.FromResult(ReadFromStream(type, readStream, content, formatterLogger)));
}
catch (Exception ex)
{
return(TaskHelpers.FromError <object>(ex));
}
}
private Task <object> ReadFromStreamAsyncCore(
Type type,
Stream readStream,
HttpContent content,
IFormatterLogger formatterLogger,
CancellationToken?cancellationToken
)
{
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
MediaTypeHeaderValue contentType =
contentHeaders == null ? null : contentHeaders.ContentType;
IFormatterLogger formatterLoggerTraceWrapper =
(formatterLogger == null)
? null
: new FormatterLoggerTraceWrapper(
formatterLogger,
TraceWriter,
Request,
InnerFormatter.GetType().Name,
ReadFromStreamAsyncMethodName
);
return(TraceWriter.TraceBeginEndAsync <object>(
Request,
TraceCategories.FormattingCategory,
TraceLevel.Info,
InnerFormatter.GetType().Name,
ReadFromStreamAsyncMethodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceReadFromStreamMessage,
type.Name,
contentType == null
? SRResources.TraceNoneObjectMessage
: contentType.ToString()
);
},
execute: () =>
{
if (cancellationToken.HasValue)
{
return InnerFormatter.ReadFromStreamAsync(
type,
readStream,
content,
formatterLoggerTraceWrapper,
cancellationToken.Value
);
}
else
{
return InnerFormatter.ReadFromStreamAsync(
type,
readStream,
content,
formatterLoggerTraceWrapper
);
}
},
endTrace: (tr, value) =>
{
tr.Message = Error.Format(
SRResources.TraceReadFromStreamValueMessage,
FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture)
);
},
errorTrace: null
));
}
internal static Task <object> DeserializeAsync(string json, Type type, MediaTypeFormatter formatter = null, IFormatterLogger formatterLogger = null)
{
formatter = formatter ?? new JsonMediaTypeFormatter();
MemoryStream ms = new MemoryStream();
byte[] bytes = Encoding.Default.GetBytes(json);
ms.Write(bytes, 0, bytes.Length);
ms.Flush();
ms.Position = 0;
return(formatter.ReadFromStreamAsync(type, ms, content: null, formatterLogger: formatterLogger));
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger, CancellationToken cancellationToken)
{
Task <object> resultTask = base.ReadFromStreamAsync(type, readStream, content, formatterLogger, cancellationToken);
var propertiesFlaggedForSanitization = type.GetProperties().Where(e => e.GetCustomAttribute <SanitizeAttribute>() != null).ToList();
if (propertiesFlaggedForSanitization.Any())
{
var result = resultTask.Result;
foreach (var propertyInfo in propertiesFlaggedForSanitization)
{
var raw = (string)propertyInfo.GetValue(result);
if (!string.IsNullOrEmpty(raw))
{
propertyInfo.SetValue(result, AntiXssEncoder.HtmlEncode(raw, true));
}
}
}
return(resultTask);
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var taskCompletionSource = new TaskCompletionSource <object>();
try
{
var memoryStream = new MemoryStream();
readStream.CopyTo(memoryStream);
var s = System.Text.Encoding.UTF8.GetString(memoryStream.ToArray());
taskCompletionSource.SetResult(s);
}
catch (Exception e)
{
taskCompletionSource.SetException(e);
}
return(taskCompletionSource.Task);
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
return(Task.Factory.StartNew(
() =>
{
using (var streamReader = new StreamReader(readStream, Encoding.UTF8))
{
var root = XElement.Load(streamReader);
object result = null;
if (content.Headers.ContentType.MediaType == "application/vnd.netmx.attr+xml")
{
result = new MBeanAttributeResource
{
Value = DeserializeValue(root.Element("Value"))
};
}
return result;
}
}));
}
/// <summary>
/// Called during deserialization to read an object of the specified <paramref name="type"/>
/// from the specified <paramref name="readStream"/>.
/// </summary>
/// <remarks>
/// Public for delegating wrappers of this class. Expected to be called only from
/// <see cref="ReadFromStreamAsync"/>.
/// </remarks>
/// <param name="type">The <see cref="Type"/> of object to read.</param>
/// <param name="readStream">The <see cref="Stream"/> from which to read.</param>
/// <param name="effectiveEncoding">The <see cref="Encoding"/> to use when reading.</param>
/// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
/// <returns>The <see cref="object"/> instance that has been read.</returns>
public virtual object ReadFromStream(
Type type,
Stream readStream,
Encoding effectiveEncoding,
IFormatterLogger formatterLogger
)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (readStream == null)
{
throw Error.ArgumentNull("readStream");
}
if (effectiveEncoding == null)
{
throw Error.ArgumentNull("effectiveEncoding");
}
using (
JsonReader jsonReader = CreateJsonReaderInternal(
type,
readStream,
effectiveEncoding
)
)
{
jsonReader.CloseInput = false;
jsonReader.MaxDepth = _maxDepth;
JsonSerializer jsonSerializer = CreateJsonSerializerInternal();
EventHandler <Newtonsoft.Json.Serialization.ErrorEventArgs> errorHandler = null;
if (formatterLogger != null)
{
// Error must always be marked as handled
// Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes
errorHandler = (sender, e) =>
{
Exception exception = e.ErrorContext.Error;
formatterLogger.LogError(e.ErrorContext.Path, exception);
e.ErrorContext.Handled = true;
};
jsonSerializer.Error += errorHandler;
}
try
{
return(jsonSerializer.Deserialize(jsonReader, type));
}
finally
{
if (errorHandler != null)
{
// Clean up the error handler in case CreateJsonSerializer() reuses a serializer
jsonSerializer.Error -= errorHandler;
}
}
}
}
public async Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger, CancellationToken cancellationToken)
{
using (var streamReader = new StreamReader(readStream))
{
return(await streamReader.ReadToEndAsync());
}
}
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));
}
}
internal static object Deserialize(string json, Type type, MediaTypeFormatter formatter = null, IFormatterLogger formatterLogger = null)
{
formatter = formatter ?? new JsonMediaTypeFormatter();
MemoryStream ms = new MemoryStream();
byte[] bytes = Encoding.Default.GetBytes(json);
ms.Write(bytes, 0, bytes.Length);
ms.Flush();
ms.Position = 0;
Task <object> readTask = formatter.ReadFromStreamAsync(type, ms, content: null, formatterLogger: formatterLogger);
readTask.WaitUntilCompleted();
if (readTask.IsFaulted)
{
throw readTask.Exception.GetBaseException();
}
return(readTask.Result);
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
IFormatterLogger formatterLogger, CancellationToken cancellationToken)
{
return(ReadFromStreamAsyncCore(type, readStream, content, formatterLogger, cancellationToken));
}
public override System.Threading.Tasks.Task <Object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger, CancellationToken cancellationToken)
{
//Do date formatting here
}
// This method reads bytes from an input stream (i.e. an "upload")
public override object ReadFromStream(Type type, System.IO.Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
// Create an in-memory buffer
var ms = new MemoryStream();
// Copy the request message body content to the in-memory buffer
readStream.CopyTo(ms);
// Deliver a byte array to the controller
return(ms.ToArray());
}
public override Task <object> ReadFromStreamAsync(Type type, Stream input, HttpContent content, IFormatterLogger formatterLogger)
{
var reader = new StreamReader(input);
Func <TextReader, Options, object> deserialize = TypedDeserializers.GetTyped(type);
object result = deserialize(reader, _options);
return(Task.FromResult(result));
}
/// <summary>Deserialize an object from the stream.</summary>
/// <param name="type">The type of object to read.</param>
/// <param name="stream">The stream from which to read.</param>
/// <param name="content">The HTTP content being read.</param>
/// <param name="formatterLogger">The trace message logger.</param>
/// <returns>Returns a deserialized object.</returns>
public override object Deserialize(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger)
{
JsonSerializer serializer = new JsonSerializer();
BsonReader reader = new BsonReader(stream);
return(serializer.Deserialize(reader, type));
}
private Task <object> ReadContentAsync(HttpRequestMessage request, Type type,
IEnumerable <MediaTypeFormatter> formatters, IFormatterLogger formatterLogger, CancellationToken cancellationToken)
{
var content = request.Content;
if (content == null)
{
var defaultValue = MediaTypeFormatter.GetDefaultValueForType(type);
return(defaultValue == null?Task.FromResult <object>(null) : Task.FromResult(defaultValue));
}
return(content.ReadAsAsync(type, formatters, formatterLogger, cancellationToken));
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var serializer = JsonSerializer.Create(JsonSerializerSettings);
return(Task.Factory.StartNew(() =>
{
using (var streamReader = new StreamReader(readStream, _encoding))
{
using (var jsonTextReader = new JsonTextReader(streamReader))
{
return serializer.Deserialize(jsonTextReader, type);
}
}
}));
}
/// <summary>
/// Read data from incoming stream.
/// </summary>
/// <param name="type"></param>
/// <param name="stream"></param>
/// <param name="content"></param>
/// <param name="formatterLogger"></param>
/// <returns></returns>
public override async Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content,
IFormatterLogger formatterLogger)
{
// Type is invalid.
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
// Stream is invalid.
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
// Find dependency resolver.
var dependencyResolver = GlobalConfiguration.Configuration.DependencyResolver;
if (dependencyResolver == null)
{
throw new ArgumentException("Dependency resolver is required.");
}
using (var dependencyScope = dependencyResolver.BeginScope())
{
try
{
// load multipart data into memory
var multipartProvider = await content.ReadAsMultipartAsync();
var httpContents = multipartProvider.Contents;
// Create an instance from specific type.
var instance = Activator.CreateInstance(type);
foreach (var httpContent in httpContents)
{
// Find parameter from content deposition.
var contentParameter = httpContent.Headers.ContentDisposition.Name.Trim('"');
var parameterParts = FindContentDispositionParameters(contentParameter);
// Content is a parameter, not a file.
if (string.IsNullOrEmpty(httpContent.Headers.ContentDisposition.FileName))
{
var value = await httpContent.ReadAsStringAsync();
await BuildRequestModelAsync(instance, parameterParts, value, dependencyScope);
continue;
}
// Content is a file.
// File retrieved from client-side.
HttpFileBase file = null;
// set null if no content was submitted to have support for [Required]
if (httpContent.Headers.ContentLength.GetValueOrDefault() > 0)
{
if (IsStreamingRequested(instance, contentParameter))
{
file = new StreamedHttpFile(
httpContent.Headers.ContentDisposition.FileName.Trim('"'),
httpContent.Headers.ContentType.MediaType,
await httpContent.ReadAsStreamAsync());
}
else
{
file = new HttpFile(
httpContent.Headers.ContentDisposition.FileName.Trim('"'),
httpContent.Headers.ContentType.MediaType,
await httpContent.ReadAsByteArrayAsync());
}
}
await BuildRequestModelAsync(instance, parameterParts, file, dependencyScope);
}
return(instance);
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(string.Empty, e);
return(GetDefaultValueForType(type));
}
}
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
return(Task.FromResult(this.DeserializeFromStream(type, readStream)));
}
