public static string getDataInRequest(HttpRequestMessage Request)
{
string ret = "";
bool Rslt = false;
MultipartMemoryStreamProvider prvdr = new MultipartMemoryStreamProvider();
Task readData = Request.Content.ReadAsMultipartAsync(prvdr).ContinueWith((readTask) =>
{
Rslt = readTask.IsCompleted;
});
readData.Wait();
if (Rslt)
{
foreach (HttpContent ctnt in prvdr.Contents)
{
// You would get hold of the inner memory stream here
Stream stream = ctnt.ReadAsStreamAsync().Result;
var sr = new StreamReader(stream);
var myStr = sr.ReadToEnd();
if (myStr != null && !myStr.Equals(""))
{
ret = Utility.Decrypt(myStr, true, Config.SECURITY_KEY);
break;
}
}
}
return(ret);
}
public async Task <ElementResponse> AddVideoForNews()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new ApplicationException("Ошибка загрузки видео");
}
var provider = new MultipartMemoryStreamProvider();
string root = HttpContext.Current.Server.MapPath("~/Files/Video/News/");
await Request.Content.ReadAsMultipartAsync(provider);
var file = provider.Contents[0];
byte[] fileArray = await file.ReadAsByteArrayAsync();
var newsId = file.Headers.ContentDisposition.FileName.Trim('\"');
Random rnd = new Random();
var code = rnd.Next(1000, 10001);
var filename = newsId + code + ".mp4";
var urlDir = root + filename;
var urlBd = $"./Files/Video/News/{filename}";
DelVideoNewsBLL.Execute(newsId);
using (FileStream fs = new FileStream(urlDir, FileMode.Create))
{
await fs.WriteAsync(fileArray, 0, fileArray.Length);
}
return(AddVideoForNewsBLL.Execute(newsId, urlDir, urlBd));
}
public async Task <HttpResponseMessage> UploadGenres()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartMemoryStreamProvider();
await this.Request.Content.ReadAsMultipartAsync(provider);
var httpContent = provider.Contents[0];
if (!ValidContentTypes.Contains(httpContent.Headers.ContentType.ToString()))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var csvData = await httpContent.ReadAsStreamAsync();
var result = this._genreService.ImportGenreConfig(csvData);
if (!result)
{
throw new Exception("Error in parsing files");
}
var response = this.Request.CreateResponse(HttpStatusCode.OK, new { Status = "Success" });
response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
return(response);
}
public async Task <System.Web.Http.IHttpActionResult> UpdateImage()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var user = User.Identity.Name;
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var fileManager = new AzureFileManager();
foreach (var file in provider.Contents)
{
var filename = file.Headers.ContentDisposition.FileName.Trim('\"');
var buffer = await file.ReadAsByteArrayAsync();
//Do whatever you want with filename and its binary data.
var result = fileManager.UploadFileAsync(buffer, $"{user}.png");//pass file stream
if (!string.IsNullOrEmpty(result.Result))
{
return(BadRequest(result.Result));
}
}
return(Ok());
}
///<summary>
///<remarks>If FILES_TO_FILESYSTEM is not defined - be aware of max_allowed_packet limit in MySQL.</remarks>
///</summary>
#if FILES_TO_FILESYSTEM
public async Task <SystemException> PutFiles(MultipartMemoryStreamProvider inFileStream, long inArticleId, string inBasePath)
{
try
{
foreach (HttpContent fileInfo in inFileStream.Contents)
{
FileStream fileStream = new FileStream(inBasePath +
$"\\{inArticleId}\\" +
fileInfo.
Headers.
ContentDisposition.
FileName.
Replace("\"", string.Empty),
FileMode.Create);
await fileInfo.CopyToAsync(fileStream);
fileStream.Close();
}
}
catch (SystemException error)
{
return(error);
}
return(null);
}
public static async Task <HttpPostedData> ParseMultipartAsync(this HttpContent postedContent)
{
var provider = new MultipartMemoryStreamProvider();
var files = new Dictionary <string, HttpPostedFile>(StringComparer.InvariantCultureIgnoreCase);
var fields = new Dictionary <string, HttpPostedField>(StringComparer.InvariantCultureIgnoreCase);
try
{
provider = await postedContent.ReadAsMultipartAsync();
//files = new Dictionary<string, HttpPostedFile>(StringComparer.InvariantCultureIgnoreCase);
//fields = new Dictionary<string, HttpPostedField>(StringComparer.InvariantCultureIgnoreCase);
foreach (var content in provider.Contents)
{
var fieldName = content.Headers.ContentDisposition.Name.Trim('"');
if (!string.IsNullOrEmpty(content.Headers.ContentDisposition.FileName))
{
var file = await content.ReadAsByteArrayAsync();
var fileName = content.Headers.ContentDisposition.FileName.Trim('"');
files.Add(fieldName, new HttpPostedFile(fieldName, fileName, file));
}
else
{
var data = await content.ReadAsStringAsync();
fields.Add(fieldName, new HttpPostedField(fieldName, data));
}
}
}
catch (Exception ex) { string str = ex.Message; }
return(new HttpPostedData(fields, files));
}
public async Task <HttpResponseMessage> Upload(int id, string type)
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
//If size of a file is not big then read file directly into stream
var streamProvider = new MultipartMemoryStreamProvider();
//If size is quite big to upload then store file to desk and then move to appropriate directory
//var streamProvider = new MultipartFormDataStreamProvider(sourcePath);
await Request.Content.ReadAsMultipartAsync(streamProvider);
List <HttpContent> streamContent = streamProvider.Contents.ToList();
/*foreach (HttpContent ctnt in streamProvider.Contents)
* {
* using (Stream stream = ctnt.ReadAsStreamAsync().Result)
* {
* stream.Seek(0, SeekOrigin.Begin);
* FileStream filestream = File.Create(remotePath+ "/"+ctnt.Headers.ContentDisposition.FileName.Replace("\"", string.Empty));
*
* stream.CopyTo(filestream);
* stream.Close();
* filestream.Close();
* }
* }*/
string contenttype = streamContent.ToList().Select(p => p.Headers.ContentType).FirstOrDefault().MediaType;
HttpResponseMessage resMessage = requestHandler.CreateGbDocObject(Request, id, type, streamContent, sourcePath);
return(resMessage);
}
/// <summary>
/// Converts the <see cref="MultipartStreamProvider.Contents"/> of the provided <paramref name="multipartProvider"/> to multi-part form-data.
/// </summary>
public async Task <FormData> Convert(MultipartMemoryStreamProvider multipartProvider)
{
var multipartFormData = new FormData();
foreach (var file in multipartProvider.Contents.Where(x => IsFile(x.Headers.ContentDisposition)))
{
var name = UnquoteToken(file.Headers.ContentDisposition.Name);
string fileName = FixFilename(file.Headers.ContentDisposition.FileName);
string mediaType = file.Headers.ContentType.MediaType;
using (var stream = await file.ReadAsStreamAsync())
{
byte[] buffer = ReadAllBytes(stream);
if (buffer.Length > 0)
{
multipartFormData.Add(name, new HttpFile(fileName, mediaType, buffer));
}
}
}
foreach (var part in multipartProvider.Contents.Where(x => x.Headers.ContentDisposition.DispositionType == "form-data" &&
!IsFile(x.Headers.ContentDisposition)))
{
var name = UnquoteToken(part.Headers.ContentDisposition.Name);
var data = await part.ReadAsStringAsync();
multipartFormData.Add(name, data);
}
return(multipartFormData);
}
public async Task <FilesUploadResponse> UploadFiles()
{
List <FileDescription> newFiles = new List <FileDescription>();
if (!Request.Content.IsMimeMultipartContent())
{
throw new Exception(); // divided by zero
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
foreach (var file in provider.Contents)
{
var filename = file.Headers.ContentDisposition.FileName.Trim('\"');
var buffer = await file.ReadAsByteArrayAsync();
//Do whatever you want with filename and its binaray data.
var id = Guid.NewGuid();
newFiles.Add(new FileDescription()
{
Id = id,
Name = filename,
Size = buffer.LongLength,
Url = "#"
});
}
StaticFileStore.AddRange(newFiles);
return(new FilesUploadResponse {
Files = newFiles
});
}
public static async Task <IEnumerable <string> > UploadFiles(HttpRequestMessage request, string uploadFolder)
{
if (!request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var root = System.Web.HttpContext.Current.Server.MapPath("~/" + uploadFolder.Replace(".", "/").Replace("\\", "/"));
Directory.CreateDirectory(root);
var provider = new MultipartMemoryStreamProvider();
await request.Content.ReadAsMultipartAsync(provider);
var fileNames = new List <string>();
foreach (var file in provider.Contents)
{
var fileName = file.Headers.ContentDisposition.FileName.Trim('\"');
fileNames.Add(fileName);
using (var contentStream = await file.ReadAsStreamAsync())
using (var fileStream = new FileStream(root + "//" + fileName, FileMode.Create))
{
await contentStream.CopyToAsync(fileStream);
}
}
return(fileNames);
}
public async Task <IHttpActionResult> UploadProductImages()
{
List <ProductImage> images = new List <ProductImage>();
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
try
{
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
foreach (var file in provider.Contents)
{
if (file.Headers.ContentLength > 0)
{
ProductImage image = new ProductImage();
image.Image = await file.ReadAsByteArrayAsync();
image.FileType = file.Headers.ContentType.MediaType;
image.FileName = file.Headers.ContentDisposition.FileName.Trim('\"');
//File.WriteAllBytes(imagePath, buffer);
images.Add(image);
}
}
SessionManager.Current.ProductImages = images;
return(Ok());
}
catch (Exception ex)
{
var response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex);
throw new HttpResponseException(response);
}
}
public async Task <IHttpActionResult> CalculateRoute(string algorithm, int origin, int destination)
{
if (!Request.Content.IsMimeMultipartContent())
{
return(StatusCode(HttpStatusCode.UnsupportedMediaType));
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
if (provider.Contents.Count == 0)
{
return(BadRequest("You have to add file with matrix for procesing"));
}
var parsedMatrix = await GetMatrixAsync(provider);
if (!parsedMatrix.Validate() || !ValidateBoundaryPoints(origin, destination, parsedMatrix.Count))
{
return(StatusCode((HttpStatusCode)422));
}
var matrix = parsedMatrix.ToSquareMatrix();
Route route = _routeService.CalculateRoute(matrix, origin - 1, destination - 1, algorithm);
return(Ok(route));
}
public async Task <IHttpActionResult> Upload()
{
var usrId = User.Identity.GetUserId();
string token;
string secret;
using (var db = new ApplicationDbContext())
{
var usr = db.Users.Where(u => u.Id == usrId).Single();
token = usr.MeoCloudAPIToken;
secret = usr.MeoCloudAPISecret;
}
if (!Request.Content.IsMimeMultipartContent())
{
throw new Exception(); // divided by zero
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
foreach (var file in provider.Contents)
{
var filename = file.Headers.ContentDisposition.FileName.Replace("\"", string.Empty);
var buffer = await file.ReadAsByteArrayAsync();
var result = await new MeoCloudProvider(token, secret).UploadFile(filename, buffer);
}
return(Ok());
}
public async Task <Guid> Create()
{
Guid?Id = null;
if (Request.Content.IsMimeMultipartContent())
{
MultipartMemoryStreamProvider provider = await Request.Content
.ReadAsMultipartAsync <MultipartMemoryStreamProvider>(new MultipartMemoryStreamProvider());
foreach (HttpContent content in provider.Contents)
{
Stream stream = content.ReadAsStreamAsync().Result;
Image image = Image.FromStream(stream);
String filePath = HostingEnvironment.MapPath("~/Content/Images");
Id = Guid.NewGuid();
string imageName = Id.ToString() + ".jpg";
String fullPath = Path.Combine(filePath, imageName);
image.Save(fullPath);
imageService.CreatePhoto(Id.Value, fullPath);
//only one!!!
break;
}
}
return(Id.Value);
}
public async Task <UploadModel> Post()
{
var uploadService = InjectorManager.GetInstance <UploadArquivoService>();
UploadModel model = null;
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider).
ContinueWith(o =>
{
var fileContent = provider.Contents.SingleOrDefault();
if (fileContent != null)
{
var fileName = fileContent.Headers.ContentDisposition.FileName.Replace("\"", string.Empty);
var type = fileContent.Headers.ContentType.MediaType;
var blob = fileContent.ReadAsByteArrayAsync().Result;
var stream = fileContent.ReadAsStreamAsync().Result;
var upload = ImageService.ResizeAndCompress(stream);
model = uploadService.SalvarArquivo(upload);
}
});
return(model);
}
public async Task <HttpResponseMessage> Upload()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var idList = new List <Guid>(MaxUploadCount);
foreach (var file in provider.Contents.Take(MaxUploadCount))
{
var fileName = file.Headers.ContentDisposition.FileName.Trim('\"');
var buffer = await file.ReadAsByteArrayAsync();
var tempFile = new TempFile
{
Id = Guid.NewGuid(),
FileName = fileName,
FileBytes = buffer
};
cacheService.GetOrSet(tempFile.Id.ToString(), () => tempFile, DateTimeOffset.Now.AddDays(1));
idList.Add(tempFile.Id);
}
var result = string.Join(",", idList);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public async Task <IHttpActionResult> AddTempPhoto()
{
if (!Request.Content.IsMimeMultipartContent())
{
return(BadRequest());
}
var provider = new MultipartMemoryStreamProvider();
// путь к папке на сервере
var root = HttpContext.Current.Server.MapPath("/StoreImages/Temp/");
await Request.Content.ReadAsMultipartAsync(provider);
foreach (var file in provider.Contents)
{
var filename = file.Headers.ContentDisposition.FileName.Trim('\"');
filename = Path.GetFileName(filename);
var fileArray = await file.ReadAsByteArrayAsync();
try
{
using (var fs = new FileStream(root + filename, FileMode.Create))
{
await fs.WriteAsync(fileArray, 0, fileArray.Length);
}
}
catch (Exception)
{
//ignored;
}
}
return(Ok());
}
public void AddScreenShot(int ProductID)
{
var result = new HttpResponseMessage(HttpStatusCode.OK);
if (Request.Content.IsMimeMultipartContent())
{
Request.Content.ReadAsMultipartAsync <MultipartMemoryStreamProvider>(new MultipartMemoryStreamProvider()).ContinueWith((task) =>
{
MultipartMemoryStreamProvider provider = task.Result;
foreach (HttpContent content in provider.Contents)
{
Stream stream = content.ReadAsStreamAsync().Result;
var image = (Bitmap)Bitmap.FromStream(stream);
Product product = db.Products.Find(ProductID);
var z = image.ImageToByteArray();
product.Screenshots.Add(new Screenshot {
ScreenShot1 = z
});
db.SaveChanges();
}
});
return;
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
public async Task <HttpResponseMessage> Post()
{
var id = Request.Headers.GetValues("studentId").FirstOrDefault();
var name = Request.Headers.GetValues("studentName").FirstOrDefault();
// Check if the request contains multipart/form-data.
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new MultipartMemoryStreamProvider();
streamProvider = await Request.Content.ReadAsMultipartAsync(streamProvider);
foreach (var item in streamProvider.Contents)//.Where(c => !string.IsNullOrEmpty(c.Headers.ContentDisposition.FileName)))
{
MemoryStream ms = new MemoryStream(await item.ReadAsByteArrayAsync());
string path = HttpContext.Current.Server.MapPath("~/photos/diploma");
var fileName = item.Headers.ContentDisposition.FileName.Replace("\"", string.Empty).Trim();
var extension = fileName.Split('.').LastOrDefault();
fileName = name + "--" + id + "." + extension;
FileStream file = new FileStream(path + "\\" + fileName, FileMode.Create, FileAccess.Write);
ms.WriteTo(file);
file.Close();
ms.Close();
int studentId;
int.TryParse(id, out studentId);
updateImageUrlCommandHandler.Execute(new Student {
Id = studentId,
ImageUrl = "/photos/diploma/" + fileName
});
}
}
return(Request.CreateResponse(HttpStatusCode.OK, new { Message = "Student registration successful. Please note down student id generated is: " + id, Id = id }));
//return Request.CreateResponse(HttpStatusCode.OK, new { message = name+ ", " + id});
}
public async Task <System.Dynamic.ExpandoObject> HttpContentToVariables(MultipartMemoryStreamProvider req)
{
dynamic res = new System.Dynamic.ExpandoObject();
foreach (HttpContent contentPart in req.Contents)
{
var contentDisposition = contentPart.Headers.ContentDisposition;
string varname = contentDisposition.Name;
if (varname == "\"BranchesId\"")
{
res.BranchesId = contentPart.ReadAsStringAsync().Result;
}
else if (varname == "\"file\"")
{
Stream stream = await contentPart.ReadAsStreamAsync();
res.fileName = String.IsNullOrEmpty(contentDisposition.FileName) ? "" : contentDisposition.FileName.Trim('"');
res.excelStream = stream;
}
else if (varname == "\"startDate\"")
{
res.startDate = contentPart.ReadAsStringAsync().Result;
}
else if (varname == "\"endDate\"")
{
res.endDate = contentPart.ReadAsStringAsync().Result;
}
}
return(res);
}
// POST: /api/videos
public async Task <HttpResponseMessage> Post()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.NotAcceptable);
}
var streamProvider = new MultipartMemoryStreamProvider();
var provider = await Request.Content.ReadAsMultipartAsync(streamProvider);
var videoInf = VideoInformation.Parse(provider.Contents);
var validationErrors = videoInf.GetErrors();
var isValid = !validationErrors.Any();
if (isValid)
{
var video =
await
this.service.CreateVideoAsync(
videoInf.Title,
videoInf.Description,
videoInf.FileInformation.Name,
videoInf.FileInformation.Type,
await videoInf.FileInformation.Data.ReadAsStreamAsync());
return(Request.CreateResponse(HttpStatusCode.Created, video));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Join("\n", validationErrors)));
}
}
public async Task <HttpResponseMessage> Post()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
try
{
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var file = provider.Contents.FirstOrDefault(x => x.Headers.ContentType != null);
var buffer = await file.ReadAsByteArrayAsync();
var contentType = file.Headers.ContentType.ToString();
var name = file.Headers.ContentDisposition.FileName.Replace("\"", "");
var mediaId = _mediaLogic.Create(buffer, contentType, name);
var response = Request.CreateResponse(HttpStatusCode.OK, mediaId.ToString());
return(response);
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public async Task <IHttpActionResult> Post()
{
try
{
// The work-around in handling files being uploaded via ajax post (thanks Microsoft)
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
// extract file name and file contents
var fileNameParam = provider.Contents[0].Headers.ContentDisposition.Parameters
.FirstOrDefault(p => p.Name.ToLower() == "filename");
var fileName = fileNameParam?.Value.Trim('"') ?? "";
var file = await provider.Contents[0].ReadAsStreamAsync();
if (file.Length == 0 || string.IsNullOrEmpty(fileName))
{
return(BadRequest("No file was provided"));
}
//Get the input S3 bucket name set on the pipeline config
var piplineResponse = _transcoderService.Pipeline();
//Create unique key and use that for the file being uploaded
var key = Guid.NewGuid().ToString();
var fileNameKey = key + Path.GetExtension(fileName);
_storageService.UploadFile(file, fileNameKey, piplineResponse.Pipeline.InputBucket);
return(Ok(fileNameKey)); //return unique so it can be used for the job.
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> UploadBackup()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
//TODO get all uploaded files
var fileName = provider.Contents[0].Headers.ContentDisposition.FileName.Trim('\"');
var buffer = await provider.Contents[0].ReadAsByteArrayAsync();
if (fileName.EndsWith("bak"))
{
string filePath = Path.Combine(backupFilePath, fileName);
//TODO: check if there is not yet a file with same name...
try
{
File.WriteAllBytes(filePath, buffer);
return(Ok("Backup successfully uploaded"));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
return(BadRequest("Error in uploading file. Not correct extension."));
}
public async Task <IHttpActionResult> SaveLuggageDocuments(int id)
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
try
{
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
foreach (var file in provider.Contents)
{
var fileName = file.Headers.ContentDisposition.FileName.Trim('\"');
var buffer = await file.ReadAsByteArrayAsync();
File.WriteAllBytes(System.Web.HttpContext.Current.Server.MapPath(@"~/DocumentsFirstNoticeOfLoss/LuggageInsurance/" + fileName), buffer);
var document = new document();
document.Name = fileName;
var documentID = _fis.AddDocument(document);
_fis.AddDocumentToFirstNoticeOfLoss(documentID, id);
}
return(Ok());
}
catch (Exception e)
{
throw new Exception("Internal error: Not saved");
}
}
protected async Task <Dictionary <string, object> > MultipartFormData()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var formParams = new Dictionary <string, object>();
foreach (var content in provider.Contents)
{
var isFile = content.Headers.ContentType != null && !content.Headers.ContentType.MediaType.StartsWith("text");
var paramName = content.Headers.ContentDisposition.Name.Replace("\"", "");
if (isFile)
{
var fileData = await content.ReadAsByteArrayAsync();
var fileName = Entities.File.Save(content.Headers.ContentDisposition.FileName.Replace("\"", ""), fileData);
formParams[paramName] = fileName;
}
else
{
formParams[paramName] = await content.ReadAsStringAsync();
}
}
return(formParams);
}
public async Task <HttpResponseMessage> Upload()
{
if (!Request.Content.IsMimeMultipartContent())
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, new Exception("Unsupported Media Type")));
}
var streamProvider = new MultipartMemoryStreamProvider();
try
{
await Request.Content.ReadAsMultipartAsync(streamProvider);
foreach (var mediaData in streamProvider.Contents.Select(
file => new MediaData
{
Id = new Guid(FormatFileName(file.Headers.ContentDisposition.FileName)),
Data = new MemoryStream(file.ReadAsByteArrayAsync().Result),
}))
{
_mediaDataService.UploadMediaData(mediaData);
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception));
}
}
public void ShouldRetrieveEmptyBodyPartFileNames()
{
var provider = new MultipartMemoryStreamProvider();
provider.BodyPartFileNames.Add("key1", "value1");
Assert.AreEqual(provider.BodyPartFileNames.Count, 0);
}
//public string TalkToStream(HttpPostedFile)
public async Task <IHttpActionResult> TalkToStream()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var file = provider.Contents[0];
var filename = file.Headers.ContentDisposition.FileName.Trim('\"');
var fileType = filename.Split('.').Last();
var buffer = await file.ReadAsByteArrayAsync();
//Do whatever you want with filename and its binary data.
var fullFile = $@"{MainForm.liveAudioFolder}\{Guid.NewGuid()}.{fileType}";
File.WriteAllBytes(fullFile, buffer);
Service.audioHandler.ProcessCommand(AudioCommand.PlayLiveVoice, fullFile);
return(Ok());
}
public virtual async Task <List <string> > PostToMemory()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var contents = new List <string>();
foreach (HttpContent ctnt in provider.Contents)
{
var stream = await ctnt.ReadAsStreamAsync();
if (stream.Length != 0)
{
var sr = new StreamReader(stream);
contents.Add(sr.ReadToEnd());
}
}
return(contents);
}
public async Task <IHttpActionResult> PostKnnTrainingFile()
{
StoreysHandler SH = new StoreysHandler(db);
SpacesHandler SpH = new SpacesHandler(db);
KnnsHandler KH = new KnnsHandler(db);
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var file = provider.Contents[0];
string filename = file.Headers.ContentDisposition.FileName.Trim('\"');
//Bytes from the binary reader stored in BlobValue array
byte[] TrainingSet = file.ReadAsByteArrayAsync().Result; //reader.ReadBytes((int)file.Length);
string trainingString = System.Text.Encoding.UTF8.GetString(TrainingSet);
//KVP<LabelMap, knnByte>,First label ID>
KeyValuePair <KeyValuePair <byte[], byte[]>, string> LabelMapKnn = KnnGenerate.GenerateTemplateTrainingFile(trainingString);
//Generate the files from the generate template method within the template method. save those 3 to db
//Storey storey = BC.GetBeaconStorey(BeaconID);
//Knn knn = new Knn();
//Once trainingSets generated, Space Guid will be saved in the LabelMapKnn string.
Guid storeyId = SpH.GetSpaceStorey(Guid.Parse(LabelMapKnn.Value)).ID;
Storey storey = SH.GetStorey(storeyId);
byte[] LabelMap = LabelMapKnn.Key.Value;
byte[] Knn = LabelMapKnn.Key.Key;
Knn knn = new Knn(storey, TrainingSet, LabelMap, Knn);
KH.PostKnn(knn);
return(Ok(storey));
}
public async Task<IHttpActionResult> Post()
{
if (!Request.Content.IsMimeMultipartContent())
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
foreach (var file in provider.Contents)
{
var filename = file.Headers.ContentDisposition.FileName.Trim('\"');
var buffer = await file.ReadAsByteArrayAsync();
//Do whatever you want with filename and its binaray data.
}
return Ok();
}
public void ShouldThrowOnNullContentDisposition()
{
var content = new StreamContent(new MemoryStream());
var provider = new MultipartMemoryStreamProvider();
bool thrown = false;
try
{
provider.GetStream(content.Headers);
}
catch (IOException)
{
thrown = true;
}
Assert.IsTrue(thrown);
}
public Picture Post()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(
new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType)
);
}
var streamProvider = new MultipartMemoryStreamProvider();
var bodyparts = Request.Content.ReadAsMultipartAsync(streamProvider).Result;
IDictionary<string, string> bodyPartFileNames = streamProvider.BodyPartFileNames;
var data = streamProvider.FilesBytes.FirstOrDefault();
var fileName = bodyPartFileNames.Select(kv => kv.Value).FirstOrDefault();
string nameField;
string descriptionField;
string tagField;
if (!bodyparts.TryGetFormFieldValue("name", out nameField))
{
nameField = fileName;
}
bodyparts.TryGetFormFieldValue("description", out descriptionField);
bodyparts.TryGetFormFieldValue("tags", out tagField);
Picture picture = null;
var image = streamProvider.FilesBytes.FirstOrDefault();
if (image != null)
{
picture = this.pictureRepository.Save(new Picture() { Name = nameField, Description = descriptionField, Tags = tagField }, image.ToArray());
if (!string.IsNullOrEmpty(picture.Tags))
{
foreach (var tag in picture.Tags.Split(','))
{
this.tagRepository.IncrementPictureCount(tag);
}
}
}
return picture;
}
public void ShouldHaveParameterLessConstructor()
{
var provider = new MultipartMemoryStreamProvider();
Assert.IsInstanceOfType(provider, typeof(MultipartMemoryStreamProvider));
}
public void ShouldThrowOnNullHeaders()
{
var provider = new MultipartMemoryStreamProvider();
bool thrown = false;
try
{
provider.GetStream(null);
}
catch (ArgumentNullException)
{
thrown = true;
}
Assert.IsTrue(thrown);
}
