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 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;
}
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;
}
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 async Task<string> UploadFileAsync(HttpContent httpContent)
{
var provider = new LocalStorageServiceProvider(_path);
await httpContent.ReadAsMultipartAsync(provider);
var fileData = provider.FileData.First();
return Path.GetFileName(fileData.LocalFileName);
}
public static async Task<MultipartFormDataStreamProvider> SaveFilesTemporarily(HttpContent content)
{
TryToCreateDirectory(DEFAULT_TEMPORARY);
// Transfer data to temporary location.
var provider = new MultipartFormDataStreamProvider(ContextualizedPath(DEFAULT_DIRECTORY, DEFAULT_TEMPORARY));
await content.ReadAsMultipartAsync(provider);
return provider;
}
static async Task<Document> ReadMultipart(DatabaseApi couchApi, HttpContent content)
{
var multipart = (await content.ReadAsMultipartAsync()).ToArray();
var jsonPart = multipart.FirstOrDefault(
part => part.Headers.ContentType != null && part.Headers.ContentType.MediaType == MediaType.Json);
if (jsonPart == null)
return null;
var document = ReadDocument(
couchApi, await jsonPart.ReadAsUtf8TextReaderAsync());
PrefillAttachmentDataGetters(multipart, document);
return document;
}
/// <summary>
/// Builds the model from the request contents
/// </summary>
/// <param name="content"></param>
/// <param name="provider"></param>
/// <returns></returns>
private async Task<ContentItemSave> GetModel(HttpContent content, MultipartFormDataStreamProvider provider)
{
var result = await content.ReadAsMultipartAsync(provider);
if (result.FormData["contentItem"] == null)
{
throw new HttpResponseException(
new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = "The request was not formatted correctly and is missing the 'contentItem' parameter"
});
}
//get the string json from the request
var contentItem = result.FormData["contentItem"];
//transform the json into an object
var model = JsonConvert.DeserializeObject<ContentItemSave>(contentItem);
//get the files
foreach (var file in result.FileData)
{
var parts = file.Headers.ContentDisposition.Name.Trim(new char[] {'\"'}).Split('_');
if (parts.Length != 2)
{
throw new HttpResponseException(
new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = "The request was not formatted correctly the file name's must be underscore delimited"
});
}
int propertyId;
if (!int.TryParse(parts[1], out propertyId))
{
throw new HttpResponseException(
new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = "The request was not formatted correctly the file name's 2nd part must be an integer"
});
}
model.UploadedFiles.Add(new ContentItemFile
{
FilePath = file.LocalFileName,
PropertyId = propertyId
});
}
return model;
}
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;
}
/// <summary>
/// Reads input stream as ProjectModel class.
/// </summary>
/// <param name="type">Target type.</param>
/// <param name="readStream">Input stream.</param>
/// <param name="content"></param>
/// <param name="formatterLogger"></param>
/// <returns></returns>
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var provider = new MultipartFormDataStreamProvider(_uploadPath);
try
{
await content.ReadAsMultipartAsync(provider);
}
catch (Exception e)
{
Trace.TraceInformation("Failed multipart message reading: {0}", e);
return null;
}
return _multipartForm.GetModel(type, new FormDataProvider(provider, formatterLogger));
}
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
IFormatterLogger formatterLogger)
{
var parts = await content.ReadAsMultipartAsync();
var obj = Activator.CreateInstance(type);
var propertiesFromObj = obj.GetType().GetRuntimeProperties().ToList();
foreach (var property in propertiesFromObj.Where(x => x.PropertyType == typeof(ContentModel)))
{
var file = parts.Contents.FirstOrDefault(x => x.Headers.ContentDisposition.Name.Contains(property.Name));
if (file == null || file.Headers.ContentLength <= 0) continue;
try
{
var fileModel = new ContentModel(file.Headers.ContentDisposition.FileName,
Convert.ToInt32(file.Headers.ContentLength), ReadFully(file.ReadAsStreamAsync().Result));
property.SetValue(obj, fileModel);
}
catch (Exception e)
{
}
}
foreach (var property in propertiesFromObj.Where(x => x.PropertyType != typeof(ContentModel)))
{
var formData =
parts.Contents.FirstOrDefault(x => x.Headers.ContentDisposition.Name.Contains(property.Name));
if (formData == null) continue;
try
{
var strValue = formData.ReadAsStringAsync().Result;
var valueType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
var value = Convert.ChangeType(strValue, valueType);
property.SetValue(obj, value);
}
catch (Exception e)
{
}
}
return obj;
}
public async Task<List<BlobUploadModel>> UploadBlobs(HttpContent httpContent)
{
var blobUploadProvider = new BlobStorageUploadProvider();
var list = await httpContent.ReadAsMultipartAsync(blobUploadProvider)
.ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
throw task.Exception;
}
var provider = task.Result;
return provider.Uploads.ToList();
});
return list; // devuelvo el modelo de la imagen subida al azure
}
public async Task<FileUploadModel> UploadBlob(HttpContent httpContent, string filterPropertyName, IEnumerable<string> supportedFileTypes = null)
{
var MultiPartProvider = new MultipartFormDataStreamProvider(Path.GetTempPath());
await httpContent.ReadAsMultipartAsync(MultiPartProvider).ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
throw task.Exception;
}
});
var fileData = MultiPartProvider.FileData.FirstOrDefault(x => x.Headers.ContentDisposition.Name == string.Concat("\"", filterPropertyName, "\""));
var blobContainer = BlobHelper.GetBlobContainer();
if (fileData == null) return null;
return await UploadOneToBlob(blobContainer, fileData, supportedFileTypes);
}
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
IFormatterLogger formatterLogger)
{
var provider = await content.ReadAsMultipartAsync();
FileData file = new FileData();
foreach (var contents in provider.Contents)
{
if (!string.IsNullOrEmpty(contents.Headers.ContentDisposition.FileName))
{
var data = await contents.ReadAsByteArrayAsync();
var fileName = contents.Headers.ContentDisposition.FileName.Trim('\"');
var fileType = contents.Headers.ContentType.MediaType;
file = new FileData(fileName, fileType, data);
}
}
return file;
}
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,
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, 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;
});
}
public async Task<List<BlobUploadModel>> UploadBlobs(HttpContent httpContent)
{
var blobUploadProvider = new BlobStorageUploadProvider();
var list = await httpContent.ReadAsMultipartAsync(blobUploadProvider)
.ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
throw task.Exception;
}
var provider = task.Result;
return provider.Uploads.ToList();
});
// TODO: Use data in the list to store blob info in your
// database so that you can always retrieve it later.
return list;
}
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
IFormatterLogger formatterLogger)
{
if(type != typeof(RawWorkTaskModel))
throw new Exception("Media formatter called for unknow type.");
try
{
var x = await content.ReadAsMultipartAsync();
var reqObj = await FormDataToWorkTaskConverter.Convert<RawWorkTaskModel>(x); //JsonConvert.DeserializeObject<responseMy>(requestString);
return reqObj;
}
catch (JsonSerializationException jex)
{
Trace.TraceInformation("request failed in media formatter. " + jex.Message);
throw;
}
catch (Exception)
{
throw;
}
}
public async Task<List<FileUploadModel>> UploadBlobs(HttpContent httpContent)
{
var MultiPartProvider = new MultipartFormDataStreamProvider(Path.GetTempPath());
await httpContent.ReadAsMultipartAsync(MultiPartProvider).ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
throw task.Exception;
}
});
var blobContainer = BlobHelper.GetBlobContainer();
List<FileUploadModel> Uploads = new List<FileUploadModel>();
foreach (var fileData in MultiPartProvider.FileData)
{
FileUploadModel fileUpload = await UploadOneToBlob(blobContainer, fileData);
Uploads.Add(fileUpload);
}
return Uploads;
}
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger, CancellationToken cancellationToken)
{
var provider = await content.ReadAsMultipartAsync();
var providerContent = provider.Contents.FirstOrDefault(x => x.Headers.ContentType.MediaType == "application/json");
AlbumModel album = new AlbumModel();
album = await providerContent.ReadAsAsync<AlbumModel>();
var files = provider.Contents.Where(x => x.Headers.ContentType.MediaType != "application/json").ToList();
album.Files = new List<ImageModel>();
foreach(var file in files)
{
album.Files.Add(new ImageModel
{
Data = await file.ReadAsByteArrayAsync(),
Name = file.Headers.ContentDisposition.FileName.NormalizeName(),
MimeType = file.Headers.ContentType.MediaType
});
}
return album;
}
/// <summary>
/// API文件上传
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
public static async Task<List<string>> Upload(HttpContent content)
{
//文件存储地址
string path = string.Format("UploadFile/{0}/", DateTime.Today.ToString("yyyyMMdd"));
string dirPath = AppDomain.CurrentDomain.BaseDirectory + path;
if (!Directory.Exists(dirPath)) Directory.CreateDirectory(dirPath);
// 采用MultipartMemoryStreamProvider
List<string> files = new List<string>();
var provider = new CustomMultipartFormDataStreamProvider(dirPath);
try
{
// Read all contents of multipart message into CustomMultipartFormDataStreamProvider.
await content.ReadAsMultipartAsync(provider);
foreach (MultipartFileData file in provider.FileData)
{
var serverPath = ServerHost + path + Path.GetFileName(file.LocalFileName);
files.Add(serverPath);
}
return files;
}
catch { return new List<string>(); }
}
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;
}
public async override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var formParts = await content.ReadAsMultipartAsync();
var jsonFormData = formParts.Contents.FirstOrDefault(p => GlobalConfiguration.Configuration.Formatters.JsonFormatter.SupportedMediaTypes.Any(m =>
m.MediaType == p.Headers.ContentType.MediaType));
if (jsonFormData == null)
throw new InvalidDataException();
var areaJson = await jsonFormData.ReadAsStringAsync();
var area = JsonConvert.DeserializeObject<DTO.Area>(areaJson);
var imageFormData = formParts.Contents.FirstOrDefault(p => p.Headers.ContentDisposition.FileName != null);
if (imageFormData != null)
{
var imageData = await imageFormData.ReadAsByteArrayAsync();
new ImageService().SaveImage(area, imageFormData.Headers.ContentDisposition.FileName, imageData);
}
return area;
}
public void ReadAsMultipartAsync_ThrowsOnReadOnlyStream()
{
HttpContent content = CreateContent(ValidBoundary, "A", "B", "C");
Assert.Throws <InvalidOperationException>(() => content.ReadAsMultipartAsync(new ReadOnlyStreamProvider()).Result);
}
/// <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;
}
public void ReadAsMultipartAsync_ThrowsOnBadStreamProvider()
{
HttpContent content = CreateContent(ValidBoundary, "A", "B", "C");
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => content.ReadAsMultipartAsync(new BadStreamProvider()).Result);
Assert.NotNull(exception.InnerException);
Assert.Equal(ExceptionStreamProviderMessage, exception.InnerException.Message);
}
/// <summary>
/// Reads the input from the POST requests and creates the appropriate job instance
/// </summary>
/// <param name="type"></param>
/// <param name="readStream"></param>
/// <param name="content"></param>
/// <param name="formatterLogger"></param>
/// <returns></returns>
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (content == null)
return null;
var tempStorage = Path.GetTempPath();
var tempStorageProvider = new MultipartFormDataStreamProvider(tempStorage);
var msp = await content.ReadAsMultipartAsync(tempStorageProvider);
Job job = null;
if (type == typeof(AccessibleConversionJob))
{
job = new AccessibleConversionJob
{
//SourceDocumnetFormat = (SourceFormat)Enum.Parse(typeof(SourceFormat), msp.FormData["sourceformat"]),//Convert.ToInt32(msp.FormData["sourceformat"]),
TargetDocumentFormat = (OutputFileFormatEnum)Enum.Parse(typeof(OutputFileFormatEnum), msp.FormData["targetdocumentformat"])//Convert.ToInt32(msp.FormData["targetformat"]),
};
if (msp.FormData.AllKeys.Contains("priority"))
{
((AccessibleConversionJob)job).Priority = (PriorityEnum)Enum.Parse(typeof(PriorityEnum), msp.FormData["priority"]);
}
else
{
((AccessibleConversionJob)job).Priority = PriorityEnum.P_Normal;
}
}
else if (type == typeof(AudioJob))
{
job = new AudioJob()
{
AudioLanguage = (Language)Enum.Parse(typeof(Language), msp.FormData["audiolanguage"]),
SpeedOptions = (AudioSpeed)Enum.Parse(typeof(AudioSpeed), msp.FormData["speedoptions"]),
FormatOptions = (AudioFormat)Enum.Parse(typeof(AudioFormat), msp.FormData["formatoptions"])
};
if (msp.FormData.AllKeys.Contains("voicepropriety"))
{
string[] props = msp.FormData["voicepropriety"].Split(':');
List<VoicePropriety> propList = new List<VoicePropriety>();
foreach (string prop in props)
{
propList.Add((VoicePropriety)Enum.Parse(typeof(VoicePropriety), prop));
}
((AudioJob)job).VoicePropriety = propList;
}
else ((AudioJob)job).VoicePropriety = new List<VoicePropriety>() { VoicePropriety.None };
}
else if (type == typeof(BrailleJob))
{
job = new BrailleJob
{
BrailleFormat = (BrailleFormat)Enum.Parse(typeof(BrailleFormat), msp.FormData["brailleformat"]),
BrailleLanguage = (Language)Enum.Parse(typeof(Language), msp.FormData["language"]),
Contraction = (BrailleContraction)Enum.Parse(typeof(BrailleContraction), msp.FormData["contraction"]),
OutputFormat = (OutputFormat)Enum.Parse(typeof(OutputFormat), msp.FormData["outputformat"]),
ConversionPath = (ConversionPath)int.Parse(msp.FormData["conversionpath"]),
CharactersPerLine = int.Parse(msp.FormData["charactersperline"]),
LinesPerPage = int.Parse(msp.FormData["linesperpage"])
};
if (msp.FormData.AllKeys.Contains("pagenumbering"))
{
((BrailleJob)job).PageNumbering = (PageNumbering)int.Parse(msp.FormData["pagenumbering"]);
}
if (msp.FormData.AllKeys.Contains("translationtable"))
{
((BrailleJob)job).TranslationTable = msp.FormData["translationtable"];
}
}
else if (type == typeof(DaisyJob))
{
job = new DaisyJob
{
DaisyOutput = (DaisyOutput)Enum.Parse(typeof(DaisyOutput), msp.FormData["daisyoutput"])
};
}
else if (type == typeof(EBookJob))
{
job = new EBookJob
{
EbookFormat = (EbookFormat)Enum.Parse(typeof(EbookFormat), msp.FormData["format"])
};
}
else if (type == typeof(HTMLtoPDFJob))
{
job = new HTMLtoPDFJob
{
paperSize = (PaperSize)Enum.Parse(typeof(PaperSize), msp.FormData["size"])
};
}
else if (type == typeof(MSOfficeJob))
{
job = new MSOfficeJob
{
MSOfficeOutput = (MSOfficeOutput)Enum.Parse(typeof(MSOfficeOutput), msp.FormData["msofficeoutput"])
};
}
else if (type == typeof(OcrConversionJob))
{
job = new OcrConversionJob
{
OcrLanguage = (Language)Enum.Parse(typeof(Language), msp.FormData["language"])
};
}
else if (type == typeof(HTMLToTextJob))
{
job = new HTMLToTextJob();
}
else if (type == typeof(RoboVideo.VideoJob))
{
job = new RoboVideo.VideoJob()
{
SubtitleLangauge = msp.FormData["language"],
SubtitleFormat = msp.FormData["format"]
};
if (msp.FormData.AllKeys.Contains("videourl"))
{
((RoboVideo.VideoJob)job).VideoUrl = msp.FormData["videourl"];
}
}
else //if (type == typeof(TranslationJob))
{
job = new TranslationJob()
{
SourceLanguage = msp.FormData["sourcelanguage"],
TargetLanguage = msp.FormData["targetlanguage"]
};
}
if (job == null)
{
Console.WriteLine("cum pula mea");
return null;
}
else
{
if (msp.FileData.Count > 0)
{
job.FileContent = File.ReadAllBytes(msp.FileData[0].LocalFileName);
string fileName = msp.FileData[0].Headers.ContentDisposition.FileName.Replace("\"", "").ToString();
job.FileName = fileName.Substring(0, fileName.LastIndexOf("."));
job.FileExtension = fileName.Substring(fileName.LastIndexOf(".") + 1);
job.MimeType = msp.FileData[0].Headers.ContentType.MediaType;
}
else if (msp.FormData["lastjobid"] != null)
{
//1) check if a guid is present and exists in the database. 2) get the byte content from the database and use it in the new job
Guid previousJobId = Guid.Parse(msp.FormData["lastjobid"]);
RoboBrailleDataContext _context = new RoboBrailleDataContext();
Job previousJob = RoboBrailleProcessor.CheckForJobInDatabase(previousJobId, _context);
if (previousJob != null)
{
job.FileContent = previousJob.ResultContent;
job.FileName = previousJob.FileName;
job.FileExtension = previousJob.ResultFileExtension;
job.MimeType = previousJob.ResultMimeType;
}
else
{
return null;
}
}
else
{
//if not assume it is a URL
if (!String.IsNullOrWhiteSpace(msp.FormData["FileContent"]))
{
string sorh = msp.FormData["FileContent"];
Uri uriResult;
bool result = Uri.TryCreate(sorh, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
if (result)
{
var webRequest = WebRequest.Create(uriResult);
using (var response = webRequest.GetResponse())
using (var httpcontent = response.GetResponseStream())
using (var reader = new StreamReader(httpcontent))
{
job.FileContent = Encoding.UTF8.GetBytes(reader.ReadToEnd());
job.FileName = DateTime.Now.Ticks + "-RoboFile";
job.FileExtension = ".html";
job.MimeType = "text/html";
}
}
else //else it must be a file
{
job.FileContent = Encoding.UTF8.GetBytes(sorh);
job.FileName = DateTime.Now.Ticks + "-RoboFile";
job.FileExtension = ".txt";
job.MimeType = "text/plain";
}
}
else
{
//it's a video job
}
}
if (type != typeof(RoboVideo.VideoJob))
{
job.InputFileHash = RoboBrailleProcessor.GetInputFileHash(job.FileContent);
}
job.Status = JobStatus.Started;
job.SubmitTime = DateTime.UtcNow.Date;
return job;
}
}
public void ReadAsMultipartAsync_ThrowsOnNullStreamProvider()
{
HttpContent content = CreateContent(ValidBoundary);
Assert.ThrowsArgumentNull(() => content.ReadAsMultipartAsync((MultipartStreamProvider)null).Wait(), "streamProvider");
}
