public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
{
var httpContext = _httpContextAccessor.HttpContext;
var defaultFormOptions = new FormOptions();
var digitalAssets = new List <DigitalAsset>();
if (!MultipartRequestHelper.IsMultipartContentType(httpContext.Request.ContentType))
{
throw new Exception($"Expected a multipart request, but got {httpContext.Request.ContentType}");
}
var mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(httpContext.Request.ContentType);
var boundary = MultipartRequestHelper.GetBoundary(
mediaTypeHeaderValue,
defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, httpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
var digitalAsset = new DigitalAsset();
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out ContentDispositionHeaderValue contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
using (var targetStream = new MemoryStream())
{
await section.Body.CopyToAsync(targetStream);
digitalAsset.Name = $"{contentDisposition.FileName}".Trim(new char[] { '"' }).Replace("&", "and");
digitalAsset.Bytes = StreamHelper.ReadToEnd(targetStream);
digitalAsset.ContentType = section.ContentType;
}
}
}
_context.DigitalAssets.Add(digitalAsset);
digitalAssets.Add(digitalAsset);
section = await reader.ReadNextSectionAsync();
}
await _context.SaveChangesAsync(cancellationToken);
return(new Response()
{
DigitalAssetIds = digitalAssets.Select(x => x.DigitalAssetId).ToList()
});
}
/// <summary>
/// Called when [action executing].
/// </summary>
/// <param name="context">The context.</param>
public override void OnActionExecuting(ActionExecutingContext context)
{
if (!MultipartRequestHelper.IsMultipartContentType(context.HttpContext.Request.ContentType))
{
context.Result = new StatusCodeResult(StatusCodes.Status400BadRequest);
return;
}
base.OnActionExecuting(context);
}
public void MultipartRequestHelperTest_HasFileContentDisposition()
{
var formdata =
new Microsoft.Net.Http.Headers.ContentDispositionHeaderValue("form-data");
formdata.FileName = "test";
formdata.FileNameStar = "1";
Assert.AreEqual("form-data; filename=test; filename*=UTF-8''1", formdata.ToString());
Assert.AreEqual(true, MultipartRequestHelper.HasFileContentDisposition(formdata));
}
public async Task <FileDto> UploadAsync(IFormFile file, int key = 0)
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
throw new LinCmsException($"The request couldn't be processed (Error 1).");
}
this.ValidFile(file);
return(await _fileService.UploadAsync(file, key));
}
public FilesController(MultipartRequestHelper multipartRequestHelper,
IMongoStreamer mongoStreamer,
ILogger <FilesController> logger,
IFilesRepository filesRepository)
{
_mongoStreamer = mongoStreamer;
_multipartRequestHelper = multipartRequestHelper;
_logger = logger;
_filesRepository = filesRepository;
}
public async Task <ActionResult <List <UploadedTempFile> > > Upload()
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
var filesAndFormData = await ParseMultipartRequest();
return(filesAndFormData.Files);
}
public async Task <ActionResult <BlobInfo[]> > UploadAssetToLocalFileSystemAsync()
{
//ToDo Now supports downloading one file, find a solution for downloading multiple files
// https://docs.microsoft.com/en-us/aspnet/core/mvc/models/file-uploads?view=aspnetcore-3.1
var result = new List <BlobInfo>();
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
var uploadPath = Path.GetFullPath(_platformOptions.LocalUploadFolderPath);
if (!Directory.Exists(uploadPath))
{
Directory.CreateDirectory(uploadPath);
}
var boundary = MultipartRequestHelper.GetBoundary(MediaTypeHeaderValue.Parse(Request.ContentType), _defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
if (section != null)
{
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out var contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
var fileName = contentDisposition.FileName.Value;
var targetFilePath = Path.Combine(uploadPath, fileName);
if (!Directory.Exists(uploadPath))
{
Directory.CreateDirectory(uploadPath);
}
using (var targetStream = System.IO.File.Create(targetFilePath))
{
await section.Body.CopyToAsync(targetStream);
}
var blobInfo = AbstractTypeFactory <BlobInfo> .TryCreateInstance();
blobInfo.Name = fileName;
//Use only file name as Url, for further access to these files need use PlatformOptions.LocalUploadFolderPath
blobInfo.Url = fileName;
blobInfo.ContentType = MimeTypeResolver.ResolveContentType(fileName);
result.Add(blobInfo);
}
}
}
return(Ok(result.ToArray()));
}
public async Task <SaveAudioResult> SaveAudioWithData()
{
var boundary = MultipartRequestHelper.GetBoundary(Request.ContentType);
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType) || boundary == null)
{
return(SaveAudioResult.UploadingError);
}
return(await fcMomentsService.SaveAudioWithDataAsync(HttpContext.Request.Body, boundary));
}
public void MultipartRequestHelperTest_boundarySucces()
{
var mediaType =
new Microsoft.Net.Http.Headers.MediaTypeHeaderValue("plain/text")
{
Boundary = new StringSegment("test")
};
var boundary = MultipartRequestHelper.GetBoundary(mediaType, 10);
Assert.AreEqual("test", boundary);
}
public async Task SaveAudio(long instanceId, long campaignId, long importNumber)
{
var boundary = MultipartRequestHelper.GetBoundary(Request.ContentType);
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType) || boundary == null)
{
return;
}
await transcriptionService.SaveAudioFileAsync(HttpContext.Request.Body, boundary, instanceId, campaignId, importNumber);
}
public static async Task <LocalMultipartFormData> CreateAsync(HttpRequest request, string folderPath,
Func <string, MultipartSection, MultipartFileInfo, Task <string> > fileHandle)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (!MultipartRequestHelper.IsMultipartContentType(request.ContentType))
{
throw new InvalidDataException("Request is not a multipart request");
}
var files = new List <LocalMultipartFileInfo>();
var formAccumulator = new KeyValueAccumulator();
var reader = GetMultipartReader(request);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
var hasContentDispositionHeader =
ContentDispositionHeaderValue.TryParse(
section.ContentDisposition,
out ContentDispositionHeaderValue contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
var formFile = new MultipartFileInfo {
Name = section.AsFileSection().Name,
FileName = section.AsFileSection().FileName,
Length = section.Body.Length
};
var savingPath = await fileHandle(folderPath, section, formFile);
files.Add(new LocalMultipartFileInfo(formFile)
{
TemporaryLocation = savingPath
});
}
else if (MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
{
formAccumulator = await AccumulateForm(formAccumulator, section, contentDisposition);
}
}
section = await reader.ReadNextSectionAsync();
}
return(new LocalMultipartFormData(formAccumulator.GetResults(), files));
}
public async Task <IActionResult> CreateGroupAsync(Guid adminUserId, CancellationToken cancellationToken)
{
if (Request.ContentType != null && !MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest("The data submitted is not in the multiform format"));
}
await _adminGroupService.CreateGroupAsync(adminUserId, Request.Body, Request.ContentType, cancellationToken);
return(Ok());
}
public async Task <IActionResult> UpdateGroupAsync(string slug, Guid userId, CancellationToken cancellationToken)
{
if (Request.ContentType != null && !MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest("The data submitted is not in the multiform format"));
}
var rowVersion = _etagService.GetIfMatch();
await _groupService.UpdateGroupMultipartDocument(userId, slug, rowVersion, Request.Body, Request.ContentType, cancellationToken);
return(Ok());
}
public async Task <IActionResult> UploadImageLarge()
{
try
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest(string.Format(MessagesConstants.ExpectedDifferentRequest, Request.ContentType)));
}
// Used to accumulate all the form url encoded key value pairs in the
// request.
var formAccumulator = new KeyValueAccumulator();
string targetFilePath = null;
var boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(Request.ContentType),
_defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
ContentDispositionHeaderValue contentDisposition;
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
targetFilePath = Path.GetTempFileName();
using (var targetStream = System.IO.File.Create(targetFilePath))
{
await section.Body.CopyToAsync(targetStream);
}
}
else if (MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
{
formAccumulator = await UploadImageLargeRefactor(formAccumulator, section, contentDisposition);
}
}
// Drains any remaining section body that has not been consumed and
// reads the headers for the next section.
section = await reader.ReadNextSectionAsync();
}
return(Ok(new ApiResponse(Microsoft.AspNetCore.Http.StatusCodes.Status200OK, true, "Image Uploaded Successfully.", targetFilePath)));
}
catch (Exception ex)
{
HttpContext.RiseError(new Exception(string.Concat("API := (Image := UploadImageLarge)", ex.Message, " Stack Trace : ", ex.StackTrace, " Inner Exception : ", ex.InnerException)));
return(Ok(someIssueInProcessing));
}
}
public async Task <IActionResult> UploadDocumentStream(Guid userId, string slug, Guid folderId, CancellationToken cancellationToken)
{
if (Request.ContentType != null && !MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest("The data submitted is not in the multiform format"));
}
await _fileService.UploadFileMultipartDocument(userId, slug, folderId, HttpContext.Request.Body, HttpContext.Request.ContentType, cancellationToken);
return(Ok());
}
public async Task <SaveExaminationAudioResult> SaveExaminationAudio()
{
var boundary = MultipartRequestHelper.GetBoundary(Request.ContentType);
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType) || boundary == null)
{
return(SaveExaminationAudioResult.Error);
}
return(await examinationAudioService.SaveAsync(HttpContext.Request.Body, boundary));
}
public async Task <IActionResult> UploadB()
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest("WTF"));
}
var formAccumulator = new KeyValueAccumulator();
var boundary = MultipartRequestHelper.GetBoundary(MediaTypeHeaderValue.Parse(Request.ContentType), 10000);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out var contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
var targetFilePath = (Path.Combine(tempPath, Guid.NewGuid().ToString("N") + ".pdf"));
using (var targetStream = System.IO.File.Create(targetFilePath)) {
await section.Body.CopyToAsync(targetStream);
}
}
else if (false && MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
{
var key = HeaderUtilities.RemoveQuotes(contentDisposition.Name);
var encoding = GetEncoding(section);
using (var streamReader = new StreamReader(
section.Body,
encoding,
detectEncodingFromByteOrderMarks: true,
bufferSize: 1024,
leaveOpen: true
)) {
var value = await streamReader.ReadToEndAsync();
if (String.Equals(value, "undefined", StringComparison.OrdinalIgnoreCase))
{
value = string.Empty;
}
formAccumulator.Append(key.ToString(), value);
if (formAccumulator.ValueCount > 100)
{
throw new InvalidDataException("Form WTF");
}
}
}
}
section = await reader.ReadNextSectionAsync();
}
return(Ok(new { Success = true }));
}
public static async System.Threading.Tasks.Task <ICollection <DigitalAsset> > Upload(IHttpContextAccessor httpContextAccessor, IAppDbContext context, CancellationToken cancellationToken)
{
var httpContext = httpContextAccessor.HttpContext;
var defaultFormOptions = new FormOptions();
var digitalAssets = new List <DigitalAsset>();
if (!MultipartRequestHelper.IsMultipartContentType(httpContext.Request.ContentType))
{
throw new Exception($"Expected a multipart request, but got {httpContext.Request.ContentType}");
}
var mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(httpContext.Request.ContentType);
var boundary = MultipartRequestHelper.GetBoundary(
mediaTypeHeaderValue,
defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, httpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out ContentDispositionHeaderValue contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
using (var targetStream = new MemoryStream())
{
await section.Body.CopyToAsync(targetStream, cancellationToken);
var name = $"{contentDisposition.FileName}".Trim(new char[] { '"' }).Replace("&", "and");
var bytes = StreamHelper.ReadToEnd(targetStream);
var contentType = section.ContentType;
var digitalAsset = new DigitalAsset(name, bytes, contentType);
context.Store(digitalAsset);
digitalAssets.Add(digitalAsset);
}
}
}
section = await reader.ReadNextSectionAsync(cancellationToken);
}
await context.SaveChangesAsync(cancellationToken);
return(digitalAssets);
}
/// <summary>
/// Creates a data element by reading the first multipart element or body of the request.
/// </summary>
private async Task <(Stream Stream, DataElement DataElement)> ReadRequestAndCreateDataElementAsync(HttpRequest request, string elementType, List <Guid> refs, Instance instance)
{
DateTime creationTime = DateTime.UtcNow;
Stream theStream;
string contentType;
string contentFileName = null;
long fileSize = 0;
if (MultipartRequestHelper.IsMultipartContentType(request.ContentType))
{
// Only read the first section of the Multipart message.
MediaTypeHeaderValue mediaType = MediaTypeHeaderValue.Parse(request.ContentType);
string boundary = MultipartRequestHelper.GetBoundary(mediaType, _defaultFormOptions.MultipartBoundaryLengthLimit);
MultipartReader reader = new MultipartReader(boundary, request.Body);
MultipartSection section = await reader.ReadNextSectionAsync();
theStream = section.Body;
contentType = section.ContentType;
bool hasContentDisposition = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out ContentDispositionHeaderValue contentDisposition);
if (hasContentDisposition)
{
contentFileName = HttpUtility.UrlDecode(contentDisposition.GetFilename());
fileSize = contentDisposition.Size ?? 0;
}
}
else
{
theStream = request.Body;
if (request.Headers.TryGetValue("Content-Disposition", out StringValues headerValues))
{
bool hasContentDisposition = ContentDispositionHeaderValue.TryParse(headerValues.ToString(), out ContentDispositionHeaderValue contentDisposition);
if (hasContentDisposition)
{
contentFileName = HttpUtility.UrlDecode(contentDisposition.GetFilename());
fileSize = contentDisposition.Size ?? 0;
}
}
contentType = request.ContentType;
}
string user = User.GetUserOrOrgId();
DataElement newData = DataElementHelper.CreateDataElement(elementType, refs, instance, creationTime, contentType, contentFileName, fileSize, user);
return(theStream, newData);
}
public async Task <IActionResult> UpdateMemberAsync(Guid userId, Guid targetUserId, CancellationToken cancellationToken)
{
if (Request.ContentType != null && !MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest("The data submitted is not in the multiform format"));
}
var rowVersion = _etagService.GetIfMatch();
await _userService.UpdateMemberAsync(userId, targetUserId, Request.Body, Request.ContentType, rowVersion, cancellationToken);
return(Ok());
}
public async Task <IActionResult> Upload()
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
var reader = new MultipartReader(MultipartRequestHelper.GetBoundary(MediaTypeHeaderValue.Parse(Request.ContentType), 100),
Request.Body);
// In this concept, only one file-content in the Request content is supported.
Guid id = Guid.NewGuid();
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
ContentDispositionHeaderValue contentDisposition;
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
var contentDestinationPath = Path.Combine(_persistenceLocation, $"{id}");
var metaDestinationPath = Path.Combine(_persistenceLocation, $"{id}.meta");
// TODO: persistence should be configurable; filesystem or database.
using (var metaFile = System.IO.File.Create(metaDestinationPath))
{
using (var sw = new StreamWriter(metaFile))
{
sw.WriteLine("originalfilename:" + Path.GetFileName(contentDisposition.FileName.Trim('\"')));
}
}
using (var targetStream = System.IO.File.Create(contentDestinationPath))
{
await section.Body.CopyToAsync(targetStream);
}
}
}
// Drains any remaining section body that has not been consumed and
// reads the headers for the next section.
section = await reader.ReadNextSectionAsync();
}
return(new OkObjectResult(new UploadResult(id.ToString())));
}
public async Task <IActionResult> UploadBotAsync()
{
var appPath = Environment.GetEnvironmentVariable("APP_PATH");
var botRootCatalog = Path.Combine(appPath, "bots");
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
var boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(Request.ContentType),
DefaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(
section.ContentDisposition,
out var contentDisposition);
var fileName = contentDisposition.FileName.ToString();
if (!IsValidFileName(fileName))
{
throw new ArgumentException($"Имя имя '{fileName}' не является корректным именем файла.");
}
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
using (var copyStream = new MemoryStream())
{
await section.Body.CopyToAsync(copyStream);
copyStream.Seek(0, SeekOrigin.Begin);
using (var targetStream = System.IO.File.Create(botRootCatalog))
{
await copyStream.CopyToAsync(targetStream).ConfigureAwait(false);
}
}
}
}
section = await reader.ReadNextSectionAsync();
}
return(BadRequest());
}
public static int GetFileCount(this HttpRequest request)
{
#if NETCORE
if (MultipartRequestHelper.IsMultipartContentType(request.ContentType))
{
if (request.Form.Files != null)
{
return(request.Form.Files.Count());
}
}
return(0);
#else
return(request.Files.Count);
#endif
}
private async Task <FilesAndFormData> ParseMultipartRequest()
{
var filesAndFormData = new FilesAndFormData {
Files = new List <UploadedTempFile>()
};
var formAccumulator = new KeyValueAccumulator();
var boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(Request.ContentType),
_defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary.Value, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
if (ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out var contentDisposition))
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
var tempFileName = await fileService.CreateTempFile(section.Body);
filesAndFormData.Files.Add(new UploadedTempFile {
OriginalName = contentDisposition.FileName.Value,
TempFileName = tempFileName
});
}
else if (MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
{
var(key, value) = await ParseFormDataSection(formAccumulator, section, contentDisposition);
formAccumulator.Append(key, value);
if (formAccumulator.ValueCount > _defaultFormOptions.ValueCountLimit)
{
throw new InvalidDataException($"Form key count limit {_defaultFormOptions.ValueCountLimit} exceeded.");
}
}
}
// Drains any remaining section body that has not been consumed and
// reads the headers for the next section.
section = await reader.ReadNextSectionAsync();
}
filesAndFormData.FormData = new FormCollection(formAccumulator.GetResults());
return(filesAndFormData);
}
public static HttpPostedFile GetFile(this HttpRequest request, string name)
{
#if NETCORE
if (MultipartRequestHelper.IsMultipartContentType(request.ContentType))
{
IFormFile file = request.Form.Files.GetFile(name);
if (file != null)
{
return(new HttpPostedFile(file));
}
}
return(null);
#else
return(request.Files[name]);
#endif
}
public async Task <IActionResult> UploadRecipe([FromForm] RecipeImage recipe)
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
try
{
using (var stream = recipe.Image.OpenReadStream())
{
var cloudBlock = await UploadToBlob(recipe.Image.FileName, null, stream);
//// Retrieve the filename of the file you have uploaded
//var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(cloudBlock.StorageUri.ToString()))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
Recipe recipeItem = new Recipe();
recipeItem.Name = recipe.Name;
recipeItem.Tags = recipe.Tags;
recipeItem.Author = recipe.Author;
recipeItem.Overview = recipe.Overview;
recipeItem.Ingridients = recipe.Ingridients;
recipeItem.Description = recipe.Description;
System.Drawing.Image image = System.Drawing.Image.FromStream(stream);
recipeItem.Height = image.Height.ToString();
recipeItem.Width = image.Width.ToString();
recipeItem.Url = cloudBlock.SnapshotQualifiedUri.AbsoluteUri;
recipeItem.Uploaded = DateTime.Now.ToString();
// public string Overview { get; set; }
//public string Ingridients { get; set; }
//public string Description { get; set; }
_context.Recipe.Add(recipeItem);
await _context.SaveChangesAsync();
return(Ok($"File: {recipe.Name} has successfully uploaded"));
}
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
}
public async Task <IActionResult> UploadFile([FromForm] RecipesImageItem recipe)
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
try
{
using (var stream = recipe.Image.OpenReadStream())
{
var cloudBlock = await UploadToBlob(recipe.Image.FileName, null, stream);
//// Retrieve the filename of the file you have uploaded
//var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(cloudBlock.StorageUri.ToString()))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
RecipesItem recipeItem = new RecipesItem();
recipeItem.Title = recipe.Title;
recipeItem.Description = recipe.Description;
recipeItem.Category = recipe.Category;
recipeItem.Subcategory = recipe.Subcategory;
recipeItem.CookTime = recipe.CookTime;
recipeItem.TimeUnit = recipe.TimeUnit;
recipeItem.Size = recipe.Size;
recipeItem.Dietary = recipe.Dietary;
recipeItem.Link = recipe.Link;
recipeItem.PostName = recipe.PostName;
System.Drawing.Image image = System.Drawing.Image.FromStream(stream);
recipeItem.Height = image.Height.ToString();
recipeItem.Width = image.Width.ToString();
recipeItem.Image = cloudBlock.SnapshotQualifiedUri.AbsoluteUri;
recipeItem.Uploaded = DateTime.Now.ToString();
_context.RecipesItem.Add(recipeItem);
await _context.SaveChangesAsync();
return(Ok($"File: {recipe.Title} has successfully uploaded"));
}
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
}
public async Task <IActionResult> PostQuestionItem([FromForm] NewQuestion newQuestion)
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
QuestionItem questionItem = new QuestionItem();
try
{
using (var stream = newQuestion.image.OpenReadStream())
{
var cloudBlock = await UploadToBlob(newQuestion.image.FileName, null, stream);
//// Retrieve the filename of the file you have uploaded
//var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(cloudBlock.StorageUri.ToString()))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
System.Drawing.Image image = System.Drawing.Image.FromStream(stream);
questionItem.diagramURL = cloudBlock.SnapshotQualifiedUri.AbsoluteUri;
}
}
catch (Exception)
{
// No images was received
questionItem.diagramURL = "";
}
try
{
questionItem.title = newQuestion.title;
questionItem.description = newQuestion.description;
questionItem.tag = newQuestion.tag;
questionItem.authorID = newQuestion.authorID;
_context.QuestionItem.Add(questionItem);
await _context.SaveChangesAsync();
return(Ok($"File: {questionItem.title} has successfully uploaded"));
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
}
public async Task <IActionResult> ImportCsv()
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest("The request must be multipart"));
}
string boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(Request.ContentType),
new FormOptions().MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
ContentDispositionHeaderValue contentDisposition;
bool hasContentDispositionHeader =
ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition);
if (!hasContentDispositionHeader)
{
section = await reader.ReadNextSectionAsync();
continue;
}
if (!MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
return(BadRequest("The file must have Content-Disposition: form-data"));
}
var command = new SaveCsvToImportCommand
{
//InputFile = file,
InputStream = section.Body,
FileName = contentDisposition.FileName.Value
};
await _mediator.Send(command);
section = await reader.ReadNextSectionAsync();
}
return(Ok());
}
public async Task <IActionResult> UploadFile([FromForm] MovieItemImage movie)
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
try
{
using (var stream = movie.Image.OpenReadStream())
{
var cloudBlock = await UploadToBlob(movie.Image.FileName, null, stream);
//// Retrieve the filename of the file you have uploaded
//var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(cloudBlock.StorageUri.ToString()))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
MovieItem movieItem = new MovieItem();
movieItem.Title = movie.Title;
movieItem.Genre = movie.Genre;
movieItem.Rating = movie.Rating;
movieItem.Description = movie.Description;
movieItem.Director = movie.Director;
movieItem.UID = movie.UID;
System.Drawing.Image image = System.Drawing.Image.FromStream(stream);
movieItem.Height = image.Height.ToString();
movieItem.Width = image.Width.ToString();
movieItem.Url = cloudBlock.SnapshotQualifiedUri.AbsoluteUri;
movieItem.Uploaded = DateTime.Now.ToString();
_context.MovieItem.Add(movieItem);
await _context.SaveChangesAsync();
return(Ok($"File: {movie.Title} has successfully uploaded"));
}
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
}
