/// <summary> /// Open blob for write by relative or absolute url /// </summary> /// <param name="url"></param> /// <returns>blob stream</returns> public virtual Stream OpenWrite(string url) { //Container name var containerName = GetContainerNameFromUrl(url); //directory path var filePath = GetFilePathFromUrl(url); if (filePath == null) { throw new NullReferenceException("filePath"); } var container = _cloudBlobClient.GetContainerReference(containerName); container.CreateIfNotExists(BlobContainerPublicAccessType.Blob); var blob = container.GetBlockBlobReference(filePath); blob.Properties.ContentType = MimeTypeResolver.ResolveContentType(Path.GetFileName(filePath)); // Leverage Browser Caching - 7days // Setting Cache-Control on Azure Blobs can help reduce bandwidth and improve the performance by preventing consumers from having to continuously download resources. // More Info https://developers.google.com/speed/docs/insights/LeverageBrowserCaching blob.Properties.CacheControl = "public, max-age=604800"; return(blob.OpenWrite()); }
/// <summary> /// Open blob for write by relative or absolute url /// </summary> /// <param name="blobUrl"></param> /// <returns>blob stream</returns> public virtual Stream OpenWrite(string blobUrl) { //Container name var containerName = GetContainerNameFromUrl(blobUrl); //directory path var filePath = GetFilePathFromUrl(blobUrl); if (filePath == null) { throw new ArgumentException(@"Cannot get file path from URL", nameof(blobUrl)); } var container = _cloudBlobClient.GetContainerReference(containerName); var requestOptions = new BlobRequestOptions() { RetryPolicy = new NoRetry() }; container.CreateIfNotExistsAsync(BlobContainerPublicAccessType.Blob, requestOptions, null).GetAwaiter().GetResult(); var blob = container.GetBlockBlobReference(filePath); blob.Properties.ContentType = MimeTypeResolver.ResolveContentType(Path.GetFileName(filePath)); // Leverage Browser Caching - 7days // Setting Cache-Control on Azure Blobs can help reduce bandwidth and improve the performance by preventing consumers from having to continuously download resources. // More Info https://developers.google.com/speed/docs/insights/LeverageBrowserCaching blob.Properties.CacheControl = BlobCacheControlPropertyValue; return(blob.OpenWriteAsync().Result); }
public async Task <IHttpActionResult> UploadAssetToLocalFileSystem() { var retVal = new List <webModel.BlobInfo>(); if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted")); } var uploadsPath = HostingEnvironment.MapPath(_uploadsUrl); var streamProvider = new CustomMultipartFormDataStreamProvider(uploadsPath); await Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith(t => { if (t.IsFaulted || t.IsCanceled) { throw new HttpResponseException(HttpStatusCode.InternalServerError); } }); foreach (var fileData in streamProvider.FileData) { var fileName = fileData.Headers.ContentDisposition.FileName.Replace("\"", string.Empty); var blobInfo = new webModel.BlobInfo { Name = fileName, Url = VirtualPathUtility.ToAbsolute(_uploadsUrl + fileName), MimeType = MimeTypeResolver.ResolveContentType(fileName) }; retVal.Add(blobInfo); } return(Ok(retVal.ToArray())); }
public string Upload(UploadStreamInfo request) { string result = null; var containerName = request.FolderName; var container = _cloudBlobClient.GetContainerReference(containerName); if (!container.Exists()) { container.CreateIfNotExists(BlobContainerPublicAccessType.Blob); } var blob = container.GetBlockBlobReference(request.FileName); blob.Properties.ContentType = MimeTypeResolver.ResolveContentType(request.FileName); using (var memoryStream = new MemoryStream()) { // upload to MemoryStream //memoryStream.SetLength(request.Length); request.FileByteStream.CopyTo(memoryStream); memoryStream.Position = 0; // fill blob blob.UploadFromStream(memoryStream); } result = blob.Uri.AbsolutePath.TrimStart('/'); return(result); }
/// <summary> /// Get blog info by url /// </summary> /// <param name="url"></param> /// <returns></returns> public virtual Task <BlobInfo> GetBlobInfoAsync(string url) { if (string.IsNullOrEmpty(url)) { throw new ArgumentNullException(nameof(url)); } BlobInfo retVal = null; var filePath = GetStoragePathFromUrl(url); ValidatePath(filePath); if (File.Exists(filePath)) { var fileInfo = new FileInfo(filePath); retVal = AbstractTypeFactory <BlobInfo> .TryCreateInstance(); retVal.Url = GetAbsoluteUrlFromPath(filePath); retVal.ContentType = MimeTypeResolver.ResolveContentType(fileInfo.Name); retVal.Size = fileInfo.Length; retVal.Name = fileInfo.Name; retVal.ModifiedDate = fileInfo.LastWriteTimeUtc; retVal.RelativeUrl = GetRelativeUrl(retVal.Url); } return(Task.FromResult(retVal)); }
/// <summary> /// Get blog info by url /// </summary> /// <param name="url"></param> /// <returns></returns> public virtual BlobInfo GetBlobInfo(string url) { if (string.IsNullOrEmpty(url)) { throw new ArgumentNullException("url"); } BlobInfo retVal = null; var filePath = GetStoragePathFromUrl(url); ValidatePath(filePath); if (File.Exists(filePath)) { var fileInfo = new FileInfo(filePath); retVal = new BlobInfo { Url = GetAbsoluteUrlFromPath(filePath), ContentType = MimeTypeResolver.ResolveContentType(fileInfo.Name), Size = fileInfo.Length, FileName = fileInfo.Name, ModifiedDate = fileInfo.LastWriteTimeUtc }; retVal.RelativeUrl = GetRelativeUrl(retVal.Url); } return(retVal); }
public virtual async Task <Stream> OpenWriteAsync(string blobUrl) { var filePath = GetFilePathFromUrl(blobUrl); if (filePath == null) { throw new ArgumentException(@"Cannot get file path from URL", nameof(blobUrl)); } var container = _blobServiceClient.GetBlobContainerClient(GetContainerNameFromUrl(blobUrl)); await container.CreateIfNotExistsAsync(PublicAccessType.Blob); var blob = container.GetBlockBlobClient(filePath); var options = new BlockBlobOpenWriteOptions { HttpHeaders = new BlobHttpHeaders { ContentType = MimeTypeResolver.ResolveContentType(Path.GetFileName(filePath)), // Leverage Browser Caching - 7days // Setting Cache-Control on Azure Blobs can help reduce bandwidth and improve the performance by preventing consumers from having to continuously download resources. // More Info https://developers.google.com/speed/docs/insights/LeverageBrowserCaching CacheControl = BlobCacheControlPropertyValue } }; return(await blob.OpenWriteAsync(true, options)); }
public void ResolveContentType_MainExtensions_ShouldExtract(string extension, string expected) { // Act var actual = MimeTypeResolver.ResolveContentType(extension); // Assert actual.Should().Be(expected); }
public void ResolveContentType_Null_ShouldThrowException() { // Arrange string nullString = null; // Act, Assert Assert.Throws <ArgumentNullException>(() => MimeTypeResolver.ResolveContentType(nullString)); }
} // constructor public void Init(int nFileSize, string sAcceptedFiles) { FileSize = nFileSize; MimeTypePrefixes = new SortedSet <string>(); MimeTypes = new SortedSet <string>(); FileExtensions = new SortedSet <string>(); m_oMimeTypesFromExtensions.Clear(); var mtr = new MimeTypeResolver(); if (sAcceptedFiles == Star) { AcceptedFiles = Star; } else { if (!string.IsNullOrWhiteSpace(sAcceptedFiles)) { foreach (var s in sAcceptedFiles.Split(',')) { var sItem = s.Trim(); if (string.IsNullOrWhiteSpace(s)) { continue; } if (sItem.StartsWith(".")) { FileExtensions.Add(sItem); m_oMimeTypesFromExtensions.Add(mtr[sItem]); continue; } // if int nPos = sItem.IndexOf(StarChar); if (nPos < 0) { MimeTypes.Add(sItem); } else { MimeTypePrefixes.Add(sItem.Substring(0, nPos)); } } // for each } // if List <string> oAccepted = new List <string>(); oAccepted.AddRange(MimeTypePrefixes.Select(s => s + Star)); oAccepted.AddRange(MimeTypes); oAccepted.AddRange(FileExtensions); AcceptedFiles = string.Join(",", oAccepted); } // if } // Init
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 <ActionResult> GetContentItemDataStream(string contentType, string storeId, [FromQuery] string relativeUrl) { var storageProvider = _blobContentStorageProviderFactory.CreateProvider(GetContentBasePath(contentType, storeId)); if ((await storageProvider.GetBlobInfoAsync(relativeUrl)) != null) { var fileStream = storageProvider.OpenRead(relativeUrl); return(File(fileStream, MimeTypeResolver.ResolveContentType(relativeUrl))); } return(NotFound()); }
public void ResolveContentType_Default() { // Arrange var impossibleExtension = ".dolphin"; // Act var actual = MimeTypeResolver.ResolveContentType(impossibleExtension); // Assert actual.Should().Be(MimeTypeResolver.DefaultMimeType); }
public static webModel.Asset ToAssetWebModel(this moduleModel.ItemAsset asset, IBlobUrlResolver blobUrlResolver) { var retVal = new webModel.Asset(); retVal.InjectFrom(asset); retVal.Name = HttpUtility.UrlDecode(System.IO.Path.GetFileName(asset.Url)); retVal.MimeType = MimeTypeResolver.ResolveContentType(retVal.Name); retVal.Url = blobUrlResolver.GetAbsoluteUrl(asset.Url); return(retVal); }
public void ResolveContentType_UrlPath_ShouldExtract() { // Arrange var testFileName = @"https://github.com/VirtoCommerce/vc-platform/blob/master/vc-logo.ico"; var expected = "image/x-icon"; // Act var actual = MimeTypeResolver.ResolveContentType(testFileName); // Assert actual.Should().Be(expected); }
public void ResolveContentType_FileName_ShouldExtract() { // Arrange var testFileName = "cat.jpeg"; var expected = "image/jpeg"; // Act var actual = MimeTypeResolver.ResolveContentType(testFileName); // Assert actual.Should().Be(expected); }
/// <summary> /// SearchAsync folders and blobs in folder /// </summary> /// <param name="folderUrl">absolute or relative path</param> /// <param name="keyword"></param> /// <returns></returns> public virtual Task <GenericSearchResult <BlobEntry> > SearchAsync(string folderUrl, string keyword) { var retVal = new GenericSearchResult <BlobEntry>(); folderUrl = folderUrl ?? _basePublicUrl; var storageFolderPath = GetStoragePathFromUrl(folderUrl); ValidatePath(storageFolderPath); if (!Directory.Exists(storageFolderPath)) { return(Task.FromResult(retVal)); } var directories = String.IsNullOrEmpty(keyword) ? Directory.GetDirectories(storageFolderPath) : Directory.GetDirectories(storageFolderPath, "*" + keyword + "*", SearchOption.AllDirectories); foreach (var directory in directories) { var directoryInfo = new DirectoryInfo(directory); var folder = AbstractTypeFactory <BlobFolder> .TryCreateInstance(); folder.Name = Path.GetFileName(directory); folder.Url = GetAbsoluteUrlFromPath(directory); folder.ParentUrl = GetAbsoluteUrlFromPath(directoryInfo.Parent.FullName); folder.RelativeUrl = GetRelativeUrl(folder.Url); retVal.Results.Add(folder); } var files = String.IsNullOrEmpty(keyword) ? Directory.GetFiles(storageFolderPath) : Directory.GetFiles(storageFolderPath, "*" + keyword + "*.*", SearchOption.AllDirectories); foreach (var file in files) { var fileInfo = new FileInfo(file); var blobInfo = AbstractTypeFactory <BlobInfo> .TryCreateInstance(); blobInfo.Url = GetAbsoluteUrlFromPath(file); blobInfo.ContentType = MimeTypeResolver.ResolveContentType(fileInfo.Name); blobInfo.Size = fileInfo.Length; blobInfo.Name = fileInfo.Name; blobInfo.ModifiedDate = fileInfo.LastWriteTimeUtc; blobInfo.RelativeUrl = GetRelativeUrl(blobInfo.Url); retVal.Results.Add(blobInfo); } retVal.TotalCount = retVal.Results.Count(); return(Task.FromResult(retVal)); }
public override Stream GetStream(HttpContent parent, HttpContentHeaders headers) { var fileName = Path.GetFileName((headers.ContentDisposition.FileName ?? headers.ContentDisposition.Name).Replace("\"", string.Empty)); var relativeUrl = _rootPath + "/" + fileName; var absoluteUrl = _blobUrlResolver.GetAbsoluteUrl(relativeUrl); BlobInfos.Add(new BlobInfo { ContentType = MimeTypeResolver.ResolveContentType(fileName), FileName = fileName, Key = relativeUrl, Url = absoluteUrl }); return(_blobProvider.OpenWrite(_rootPath + "/" + fileName)); }
/// <summary> /// Search folders and blobs in folder /// </summary> /// <param name="folderUrl">absolute or relative path</param> /// <param name="keyword"></param> /// <returns></returns> public virtual BlobSearchResult Search(string folderUrl, string keyword) { var retVal = new BlobSearchResult(); folderUrl = folderUrl ?? _basePublicUrl; var storageFolderPath = GetStoragePathFromUrl(folderUrl); ValidatePath(storageFolderPath); if (!Directory.Exists(storageFolderPath)) { return(retVal); } var directories = String.IsNullOrEmpty(keyword) ? Directory.GetDirectories(storageFolderPath) : Directory.GetDirectories(storageFolderPath, "*" + keyword + "*", SearchOption.AllDirectories); foreach (var directory in directories) { var directoryInfo = new DirectoryInfo(directory); var folder = new BlobFolder { Name = Path.GetFileName(directory), Url = GetAbsoluteUrlFromPath(directory), ParentUrl = GetAbsoluteUrlFromPath(directoryInfo.Parent.FullName) }; folder.RelativeUrl = GetRelativeUrl(folder.Url); retVal.Folders.Add(folder); } var files = String.IsNullOrEmpty(keyword) ? Directory.GetFiles(storageFolderPath) : Directory.GetFiles(storageFolderPath, "*" + keyword + "*.*", SearchOption.AllDirectories); foreach (var file in files) { var fileInfo = new FileInfo(file); var blobInfo = new BlobInfo { Url = GetAbsoluteUrlFromPath(file), ContentType = MimeTypeResolver.ResolveContentType(fileInfo.Name), Size = fileInfo.Length, FileName = fileInfo.Name, ModifiedDate = fileInfo.LastWriteTimeUtc }; blobInfo.RelativeUrl = GetRelativeUrl(blobInfo.Url); retVal.Items.Add(blobInfo); } return(retVal); }
public static webModel.ProductAssetBase ToWebModel(this moduleModel.ItemAsset asset, IBlobUrlResolver blobUrlResolver) { webModel.ProductAssetBase retVal = new webModel.ProductImage(); if (asset.Type == moduleModel.ItemAssetType.File) { var productAsset = new webModel.ProductAsset(); productAsset.Name = HttpUtility.UrlDecode(System.IO.Path.GetFileName(asset.Url)); productAsset.MimeType = MimeTypeResolver.ResolveContentType(productAsset.Name); retVal = productAsset; } retVal.InjectFrom(asset); retVal.Url = blobUrlResolver.GetAbsoluteUrl(asset.Url); retVal.RelativeUrl = asset.Url; return(retVal); }
private BlobInfo ConvertBlobToBlobInfo(BlobClient blob, BlobProperties props) { var absoluteUrl = blob.Uri; var relativeUrl = UrlHelperExtensions.Combine(GetContainerNameFromUrl(blob.Uri.ToString()), EscapeUri(blob.Name)); var fileName = Path.GetFileName(Uri.UnescapeDataString(blob.Name)); var contentType = MimeTypeResolver.ResolveContentType(fileName); return(new BlobInfo { Url = absoluteUrl.ToString(), Name = fileName, ContentType = contentType, Size = props.ContentLength, ModifiedDate = props.LastModified.DateTime, RelativeUrl = relativeUrl }); }
private BlobInfo ConvertBlobToBlobInfo(BlobItem blob, string baseUri) { var absoluteUrl = UrlHelperExtensions.Combine(baseUri, EscapeUri(blob.Name)); var relativeUrl = absoluteUrl.Replace(EscapeUri(_blobServiceClient.Uri.ToString()), string.Empty); var fileName = Path.GetFileName(blob.Name); var contentType = MimeTypeResolver.ResolveContentType(fileName); return(new BlobInfo { Url = absoluteUrl, Name = fileName, ContentType = contentType, Size = blob.Properties.ContentLength ?? 0, ModifiedDate = blob.Properties.LastModified?.DateTime, RelativeUrl = relativeUrl }); }
private BlobInfo ConvertBlobToBlobInfo(ICloudBlob cloudBlob) { var relativeUrl = cloudBlob.Uri.LocalPath; var absoluteUrl = GetAbsoluteUrl(cloudBlob.Uri.PathAndQuery); var fileName = Path.GetFileName(Uri.UnescapeDataString(cloudBlob.Uri.ToString())); var contentType = MimeTypeResolver.ResolveContentType(fileName); return(new BlobInfo { Url = absoluteUrl, FileName = fileName, ContentType = contentType, Size = cloudBlob.Properties.Length, ModifiedDate = cloudBlob.Properties.LastModified?.DateTime, RelativeUrl = relativeUrl }); }
public string Upload(UploadStreamInfo request) { string result = null; var directoryPath = DefaultBlobContainerName; if (!string.IsNullOrEmpty(request.FolderName)) { directoryPath = request.FolderName; } //Container name var containerName = GetContainerNameFromUrl(directoryPath); //directory path directoryPath = GetDirectoryPathFromUrl(directoryPath); var container = _cloudBlobClient.GetContainerReference(containerName); container.CreateIfNotExists(BlobContainerPublicAccessType.Blob); ICloudBlob blob = null; if (String.IsNullOrEmpty(directoryPath)) { blob = container.GetBlockBlobReference(request.FileName); } else { directoryPath += directoryPath.EndsWith(_cloudBlobClient.DefaultDelimiter) ? request.FileName : _cloudBlobClient.DefaultDelimiter + request.FileName; blob = container.GetBlockBlobReference(directoryPath); } blob.Properties.ContentType = MimeTypeResolver.ResolveContentType(request.FileName); using (var memoryStream = new MemoryStream()) { // upload to MemoryStream //memoryStream.SetLength(request.Length); request.FileByteStream.CopyTo(memoryStream); memoryStream.Position = 0; // fill blob blob.UploadFromStream(memoryStream); } result = blob.Uri.AbsolutePath.TrimStart('/'); return(result); }
public Attachment CreateAttachment(IUnitOfWork unitOfWork, int userId, string fileName, byte[] content, ITransactionWrapper tran) { var saveFileResult = FileService.SaveFileWithUniqueName(fileName, content); var genAction = new GenericCatchErrorAction(() => FileService.DeleteFile(saveFileResult.GenFileName) , $"Error while remove file in save method, path {saveFileResult.GenFileName}"); tran.RegisterAfterRollbackAction(genAction); var attachment = unitOfWork.Attachments.CreateEmpty(); attachment.CreatedByUserId = userId; attachment.CreatedDate = DateTime.Now; attachment.ContentType = MimeTypeResolver.Resolve(fileName); attachment.FileSize = content.Length; attachment.FileName = fileName; attachment.GenFileName = saveFileResult.GenFileName; return(attachment); }
public static webModel.Asset ToWebModel(this coreModel.Asset asset, IBlobUrlResolver blobUrlResolver) { var retVal = new webModel.Asset(); retVal.InjectFrom(asset); if (asset.Name == null) { retVal.Name = HttpUtility.UrlDecode(System.IO.Path.GetFileName(asset.Url)); } if (asset.MimeType == null) { retVal.MimeType = MimeTypeResolver.ResolveContentType(asset.Name); } if (blobUrlResolver != null) { retVal.Url = blobUrlResolver.GetAbsoluteUrl(asset.Url); } retVal.RelativeUrl = asset.Url; return(retVal); }
/// <summary> /// Open blob for write by relative or absolute url /// </summary> /// <param name="url"></param> /// <returns>blob stream</returns> public virtual Stream OpenWrite(string url) { //Container name var containerName = GetContainerNameFromUrl(url); //directory path var filePath = GetFilePathFromUrl(url); if (filePath == null) { throw new NullReferenceException("filePath"); } var container = _cloudBlobClient.GetContainerReference(containerName); container.CreateIfNotExists(BlobContainerPublicAccessType.Blob); var blob = container.GetBlockBlobReference(filePath); blob.Properties.ContentType = MimeTypeResolver.ResolveContentType(Path.GetFileName(filePath)); return(blob.OpenWrite()); }
//----------------------------------------------------------------------------------- public ActionResult File(int id) { var f = _docRepo.Get(id); if (f != null) { var document = f.BinaryBody; var cd = new System.Net.Mime.ContentDisposition { FileName = f.DocName, Inline = true, }; Response.AppendHeader("Content-Disposition", cd.ToString()); var mtr = new MimeTypeResolver(); MimeType oExtMimeType = mtr.Get(f.DocName); FileResult fs = new FileContentResult(f.BinaryBody, oExtMimeType.PrimaryMimeType); Log.Debug("fs {1} mime type {0}", oExtMimeType, f.DocName); if (fs.ContentType.Contains("image") || fs.ContentType.Contains("pdf") || fs.ContentType.Contains("html") || fs.ContentType.Contains("text")) { return(fs); } var pdfDocument = AgreementRenderer.ConvertToPdf(document); if (pdfDocument != null) { return(File(pdfDocument, "application/pdf")); } return(fs); } return(null); }
public Template() { m_oMime = new MimeTypeResolver(); MimeType = m_oMime[null]; TemplateType = TemplateType.Other; } // Template
public async Task<IActionResult> UploadAssetAsync([FromQuery] string folderUrl, [FromQuery]string url = null, [FromQuery]string name = null) { if (url == null && !MultipartRequestHelper.IsMultipartContentType(Request.ContentType)) { return BadRequest($"Expected a multipart request, but got {Request.ContentType}"); } var retVal = new List<BlobInfo>(); if (url != null) { var fileName = name ?? HttpUtility.UrlDecode(Path.GetFileName(url)); var fileUrl = folderUrl + "/" + fileName; using (var client = new WebClient()) using (var blobStream = _blobProvider.OpenWrite(fileUrl)) using (var remoteStream = client.OpenRead(url)) { remoteStream.CopyTo(blobStream); var blobInfo = AbstractTypeFactory<BlobInfo>.TryCreateInstance(); blobInfo.Name = fileName; blobInfo.RelativeUrl = fileUrl; blobInfo.Url = _urlResolver.GetAbsoluteUrl(fileUrl); retVal.Add(blobInfo); } } else { 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(); if (section != null) { var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out ContentDispositionHeaderValue contentDisposition); if (hasContentDispositionHeader) { if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition)) { var fileName = contentDisposition.FileName.Value; targetFilePath = folderUrl + "/" + fileName; using (var targetStream = _blobProvider.OpenWrite(targetFilePath)) { await section.Body.CopyToAsync(targetStream); } var blobInfo = AbstractTypeFactory<BlobInfo>.TryCreateInstance(); blobInfo.Name = fileName; blobInfo.RelativeUrl = targetFilePath; blobInfo.Url = _urlResolver.GetAbsoluteUrl(targetFilePath); blobInfo.ContentType = MimeTypeResolver.ResolveContentType(fileName); retVal.Add(blobInfo); } } } } return Ok(retVal.ToArray()); }