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 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 void IsMimeMultipartContentThrowsOnNullString(string boundary)
{
HttpContent content = CreateContent(boundary);
Assert.NotNull(content);
foreach (var subtype in CommonUnitTestDataSets.EmptyStrings)
{
Assert.ThrowsArgumentNull(() =>
{
content.IsMimeMultipartContent(subtype);
}, "subtype");
}
}
/// <summary>
/// Reads a file stream asynchronously.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>A key/value pair that contains the name of the file with a stream value.</returns>
/// <exception cref="System.Web.Http.HttpResponseException">
/// </exception>
public static async Task <FileStreamContent> ReadAsFileStreamAsync(this HttpContent content, CancellationToken cancellationToken)
{
if (content.IsMimeMultipartContent("form-data"))
{
content = (await content.ReadAsMultipartAsync(cancellationToken)).Contents.FirstOrDefault();
}
if (content == null || string.IsNullOrEmpty(content.Headers.ContentDisposition.FileName))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
return(new FileStreamContent(
content.Headers.ContentDisposition.FileName.Replace("\"", string.Empty),
await content.ReadAsStreamAsync()));
}
public async Task<FormData> Convert(HttpContent content)
{
if(content == null)
throw new ArgumentNullException("content");
if (!content.IsMimeMultipartContent())
{
throw new Exception("Unsupported Media Type");
}
MultipartMemoryStreamProvider multipartProvider = await content.ReadAsMultipartAsync();
var multipartFormData = await Convert(multipartProvider);
return multipartFormData;
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (!content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var taskCompletionSource = new TaskCompletionSource<object>();
content.ReadAsMultipartAsync().ContinueWith(t =>
{
if (t.IsFaulted || t.IsCanceled)
throw new HttpResponseException(HttpStatusCode.InternalServerError);
var fileContents = t.Result.Contents.Where(x => SupportedMediaTypes.Contains(x.Headers.ContentType))
.ToArray();
if (!fileContents.Any())
{
taskCompletionSource.SetResult(null);
}
else
{
var fileMedias = new List<FileMedia>();
foreach (var fileContent in fileContents)
{
var fileName = fileContent.Headers.ContentDisposition.FileName;
var mediaType = fileContent.Headers.ContentType.MediaType;
using (var imgStream = fileContent.ReadAsStreamAsync().Result)
{
var imageBuffer = imgStream.ReadFully();
var result = new FileMedia(fileName, mediaType, imageBuffer);
fileMedias.Add(result);
}
}
if (fileMedias.Count == 1)
{
taskCompletionSource.SetResult(fileMedias.Single());
}
else
{
taskCompletionSource.SetResult(fileMedias);
}
}
});
return taskCompletionSource.Task;
}
public override async Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
TransportContext transportContext)
{
if (!content.IsMimeMultipartContent())
throw new Exception("Not a Multipart Content");
var boudaryParameter = content.Headers.ContentType.Parameters.FirstOrDefault(m => m.Name == "boundary" && !String.IsNullOrWhiteSpace(m.Value));
if (boudaryParameter == null)
throw new Exception("multipart boundary not found");
var objectToMultipartDataByteArrayConverter = new ObjectToMultipartDataByteArrayConverter();
byte[] multipartData = objectToMultipartDataByteArrayConverter.Convert(value, boudaryParameter.Value);
await writeStream.WriteAsync (multipartData, 0, multipartData.Length);
content.Headers.ContentLength = multipartData.Length;
}
/// <summary>
/// Looks for a parameter in the <see cref="MediaTypeHeaderValue"/>.
/// </summary>
/// <returns>The matching parameter or null if none found.</returns>
private static NameValueHeaderValue FindMultipartRelatedParameter(HttpContent content, string parameterName)
{
// If no parent then we are done
if (content == null)
{
return(null);
}
// Check that we have a parent content type and that it is indeed multipart/related
MediaTypeHeaderValue parentContentType = content.Headers.ContentType;
if (parentContentType == null || !content.IsMimeMultipartContent(RelatedSubType))
{
return(null);
}
// Look for parameter
return(parentContentType.Parameters.FirstOrDefault(nvp => String.Equals(nvp.Name, parameterName, StringComparison.OrdinalIgnoreCase)));
}
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");
if (!content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var retValue = content.ReadAsMultipartAsync().ContinueWith<object>(t => RetrieveMediaPart(t));
return retValue;
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
IFormatterLogger formatterLogger)
{
if (content.IsMimeMultipartContent()) {
var provider = GetMultipartProvider();
try {
content.ReadAsMultipartAsync(provider);
object uploadData = GetFormData(type, provider);
return Task.FromResult(uploadData);
}
catch (Exception e) {
formatterLogger.LogError(e.Message, e);
}
}
return base.ReadFromStreamAsync(type, readStream, content, formatterLogger);
}
public override Task<object> ReadFromStreamAsync(Type type, System.IO.Stream readStream, HttpContent content, System.Net.Http.Formatting.IFormatterLogger formatterLogger)
{
if (!content.IsMimeMultipartContent())
{
throw new System.Web.Http.HttpResponseException(System.Net.HttpStatusCode.UnsupportedMediaType);
}
var parts = content.ReadAsMultipartAsync();
return Task.Factory.StartNew<object>(() =>
{
object data = null;
List<KeyValuePair<string, string>> valueCollection = new List<KeyValuePair<string, string>>();
foreach (var partContent in parts.Result.Contents)
{
if (partContent.Headers.ContentType == null)
{
var value = partContent.ReadAsStringAsync().Result;
var name = partContent.Headers.ContentDisposition.Name;
name = name.Substring(1, name.Length - 2);
valueCollection.Add(new KeyValuePair<string, string>(name, value));
}
else if (partContent.Headers.ContentType != null
&& partContent.Headers.ContentType.MediaType == "application/json")
{
var partBody = partContent.ReadAsStringAsync().Result;
data = JsonConvert.DeserializeObject(partBody, type);
break;
}
}
if (data == null)
{
if (valueCollection.Count > 0)
{
data = new FormDataCollection(valueCollection).ConvertToObject(type);
//var valueCollectionJson = valueCollection.ToJson();
//data = JsonConvert.DeserializeObject(valueCollectionJson, type);
}
}
return data;
});
}
private async Task<string> UploadAnyFileAsync(
HttpContent httpContent,
string[] allowedExtensions,
string folderPath)
{
if (!httpContent.IsMimeMultipartContent("form-data"))
{
throw new NotSupportedException();
}
var provider = new CustomMultipartStreamProvider(folderPath);
await httpContent.ReadAsMultipartAsync(provider);
var fullFileName = provider.FileData.First().LocalFileName;
var extension = GetFileExtension(fullFileName);
if (!allowedExtensions.Contains(extension))
{
await Task.Factory.StartNew(() => File.Delete(fullFileName));
throw new InvalidDataException("Extension {0} is not allowed".FormatString(extension));
}
return fullFileName;
}
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
IFormatterLogger formatterLogger,
CancellationToken cancellationToken)
{
if (!content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var fileDto = new FileDto();
var parts = await content.ReadAsMultipartAsync(cancellationToken);
//file content
var fileContent = parts.Contents.FirstOrDefault(x => x.Headers.ContentDisposition.Name == "\"file\"");
//file information
var data = parts.Contents.FirstOrDefault(x => x.Headers.ContentDisposition.Name == "\"data\"");
var dataStr = await data.ReadAsStringAsync();
fileDto = JsonConvert.DeserializeObject<FileDto>(dataStr);
fileDto.File = await fileContent.ReadAsStreamAsync();
return fileDto;
}
/// <summary>
/// Upload a file sent in an http request
/// </summary>
/// <param name="httpContent">request's content</param>
/// <returns>Error message or null</returns>
private async Task<String> AddFormatFromHttpContent(HttpContent httpContent, DocumentFormat format)
{
if (httpContent == null || !httpContent.IsMimeMultipartContent())
return "Attachment not found!";
var provider = await httpContent.ReadAsMultipartAsync(
new FormatStoreMultipartStreamProvider(_blobStore, format)
);
if (provider.Filename == null)
return "Attachment not found!";
if (provider.FormData["custom-data"] != null)
{
_customData = JsonConvert.DeserializeObject<DocumentCustomData>(provider.FormData["custom-data"]);
}
_fileName = provider.Filename;
_blobId = provider.BlobId;
return null;
}
/// <summary>
/// Upload a file sent in an http request
/// </summary>
/// <param name="httpContent">request's content</param>
/// <returns>Error message or null</returns>
private async Task<String> UploadFromHttpContent(HttpContent httpContent)
{
if (httpContent == null || !httpContent.IsMimeMultipartContent())
return "Attachment not found!";
var provider = await httpContent.ReadAsMultipartAsync(
new FileStoreMultipartStreamProvider(_blobStore, _configService)
);
if (provider.Filename == null)
return "Attachment not found!";
if (provider.IsInvalidFile)
return string.Format("Unsupported file {0}", provider.Filename);
if (provider.FormData["custom-data"] != null)
{
_customData = JsonConvert.DeserializeObject<DocumentCustomData>(provider.FormData["custom-data"]);
}
_fileName = provider.Filename;
_blobId = provider.BlobId;
return null;
}
/// <summary>
/// Asynchronously deserializes an object of the specified type.
/// </summary>
/// <returns>
/// A <see cref="T:System.Threading.Tasks.Task" /> whose result will be an object of the given type.
/// </returns>
/// <param name="type">The type of the object to deserialize.</param>
/// <param name="readStream">The <see cref="T:System.IO.Stream" /> to read.</param>
/// <param name="content">The <see cref="T:System.Net.Http.HttpContent" />, if available. It may be null.</param>
/// <param name="formatterLogger">The <see cref="T:System.Net.Http.Formatting.IFormatterLogger" /> to log events to.</param>
/// <param name="cancellationToken">The token to cancel the operation.</param>
public override async Task<object> ReadFromStreamAsync(Type type,
Stream readStream,
HttpContent content,
IFormatterLogger formatterLogger,
CancellationToken cancellationToken)
{
if (!content.IsMimeMultipartContent())
{
throw new FormatException("Only multipart/form-data supported");
}
var allProps = type.GetProperties().ToDictionary(x => x.Name, StringComparer.InvariantCultureIgnoreCase);
var instance = Activator.CreateInstance(type);
var mmsp = await content.ReadAsMultipartAsync();
foreach (var httpContent in mmsp.Contents)
{
var pName = StrHelper.UnquoteToken(httpContent.Headers.ContentDisposition.Name);
PropertyInfo pi;
if (!allProps.TryGetValue(pName, out pi))
{
continue;
}
object value;
if (httpContent.Headers.ContentType == null)
{
var converter = TypeDescriptor.GetConverter(pi.PropertyType);
value = converter.ConvertFromString(await httpContent.ReadAsStringAsync());
}
else
{
var reader = _mediaTypeFormatterCollection.FindReader(pi.PropertyType, httpContent.Headers.ContentType);
if (reader == null)
{
throw new InvalidOperationException(
$"Could not found reader for type {pi.PropertyType} with ContentTye {httpContent.Headers.ContentType}");
}
value = await reader.ReadFromStreamAsync(pi.PropertyType,
await httpContent.ReadAsStreamAsync(),
httpContent,
formatterLogger,
cancellationToken);
}
_propertyHelper.Set(pi, instance, value);
}
return instance;
}
/// <summary>
/// Looks for a parameter in the <see cref="MediaTypeHeaderValue"/>.
/// </summary>
/// <returns>The matching parameter or null if none found.</returns>
private static NameValueHeaderValue FindMultipartRelatedParameter(HttpContent content, string parameterName)
{
// If no parent then we are done
if (content == null)
{
return null;
}
// Check that we have a parent content type and that it is indeed multipart/related
MediaTypeHeaderValue parentContentType = content.Headers.ContentType;
if (parentContentType == null || !content.IsMimeMultipartContent(RelatedSubType))
{
return null;
}
// Look for parameter
return parentContentType.Parameters.FirstOrDefault(nvp => String.Equals(nvp.Name, parameterName, StringComparison.OrdinalIgnoreCase));
}