/// <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());
}
