private string GetParentUrl(string baseUri, string blobPrefix)
{
var segments = GetOutlineFromUrl(blobPrefix);
var parentPath = string.Join(Delimiter, segments.Take(segments.Length - 1));
return(UrlHelperExtensions.Combine(baseUri, EscapeUri(parentPath)));
}
protected virtual async Task MoveAsync(string oldUrl, string newUrl, bool isCopy = false)
{
string oldPath, newPath;
var isFolderRename = string.IsNullOrEmpty(Path.GetFileName(oldUrl));
var containerName = GetContainerNameFromUrl(oldUrl);
//if rename file
if (!isFolderRename)
{
oldPath = GetFilePathFromUrl(oldUrl);
newPath = GetFilePathFromUrl(newUrl);
}
else
{
oldPath = GetDirectoryPathFromUrl(oldUrl);
newPath = GetDirectoryPathFromUrl(newUrl);
}
var taskList = new List <Task>();
var blobContainer = _blobServiceClient.GetBlobContainerClient(containerName);
var blobItems = blobContainer.GetBlobsAsync(prefix: oldPath);
await foreach (var blobItem in blobItems)
{
var blobName = UrlHelperExtensions.Combine(containerName, blobItem.Name);
var newBlobName = blobName.Replace(oldPath, newPath);
taskList.Add(MoveBlob(blobContainer, blobName, newBlobName, isCopy));
}
await Task.WhenAll(taskList);
}
public virtual async Task RemoveAsync(string[] urls)
{
foreach (var url in urls)
{
var absoluteUri = url.IsAbsoluteUrl()
? new Uri(url).ToString()
: UrlHelperExtensions.Combine(_blobServiceClient.Uri.ToString(), url);
var blobContainer = GetBlobContainer(GetContainerNameFromUrl(absoluteUri));
var isFolder = string.IsNullOrEmpty(Path.GetFileName(absoluteUri));
var blobSearchPrefix = isFolder ? GetDirectoryPathFromUrl(absoluteUri)
: GetFilePathFromUrl(absoluteUri);
if (string.IsNullOrEmpty(blobSearchPrefix))
{
await blobContainer.DeleteIfExistsAsync();
}
else
{
var blobItems = blobContainer.GetBlobsAsync(prefix: blobSearchPrefix);
await foreach (var blobItem in blobItems)
{
var blobClient = blobContainer.GetBlobClient(blobItem.Name);
await blobClient.DeleteIfExistsAsync();
}
}
}
}
public IBlobContentStorageProvider CreateProvider(string basePath)
{
var clonedOptions = _options.Clone() as AzureContentBlobOptions;
clonedOptions.RootPath = UrlHelperExtensions.Combine(clonedOptions.RootPath, basePath);
return(new AzureContentBlobStorageProvider(new OptionsWrapper <AzureContentBlobOptions>(clonedOptions), _platformOptions, _settingsManager));
}
private string GetExportFilePath(string entityName)
{
if (string.IsNullOrEmpty(_platformOptions.DefaultExportFolder))
{
throw new PlatformException($"{nameof(_platformOptions.DefaultExportFolder)} must be set.");
}
const string template = "{0}_{1:yyyyMMddHHmmss}.csv";
var result = string.Format(template, entityName, DateTime.UtcNow);
return(UrlHelperExtensions.Combine(_platformOptions.DefaultExportFolder, result));
}
/// <summary>
/// Chroot url (artificial add parent 'chroot' folder)
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
private string NormalizeUrl(string url)
{
var result = _options.RootPath;
if (!string.IsNullOrEmpty(url))
{
if (url.IsAbsoluteUrl())
{
url = Uri.UnescapeDataString(new Uri(url).AbsolutePath);
}
result = UrlHelperExtensions.Combine(_options.RootPath, url.Replace(_options.RootPath, string.Empty));
}
return(result);
}
public async Task ExportBackgroundAsync(ExportDataRequest request, ExportPushNotification notification, IJobCancellationToken cancellationToken, PerformContext context)
{
void progressCallback(ExportProgressInfo x)
{
notification.Patch(x);
notification.JobId = context.BackgroundJob.Id;
_pushNotificationManager.Send(notification);
}
try
{
if (string.IsNullOrEmpty(_platformOptions.DefaultExportFolder))
{
throw new PlatformException($"{nameof(_platformOptions.DefaultExportFolder)} should be set.");
}
var fileName = string.Format(FileNameTemplate, DateTime.UtcNow);
// Do not like provider creation here to get file extension, maybe need to pass created provider to Exporter.
// Create stream inside Exporter is not good as it is not Exporter resposibility to decide where to write.
var provider = _exportProviderFactory.CreateProvider(request);
if (!string.IsNullOrEmpty(provider.ExportedFileExtension))
{
fileName = Path.ChangeExtension(fileName, provider.ExportedFileExtension);
}
var url = UrlHelperExtensions.Combine(_platformOptions.DefaultExportFolder, fileName);
using (var blobStream = _blobStorageProvider.OpenWrite(url))
{
_dataExporter.Export(blobStream, request, progressCallback, new JobCancellationTokenWrapper(cancellationToken));
}
notification.DownloadUrl = _blobUrlResolver.GetAbsoluteUrl(url);
}
catch (JobAbortedException)
{
//do nothing
}
catch (Exception ex)
{
notification.Errors.Add(ex.ExpandExceptionMessage());
}
finally
{
notification.Description = "Export finished";
notification.Finished = DateTime.UtcNow;
await _pushNotificationManager.SendAsync(notification);
}
}
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(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
});
}
public string GetAbsoluteUrl(string blobKey)
{
var result = blobKey;
if (!blobKey.IsAbsoluteUrl())
{
var baseUrl = _blobServiceClient.Uri.AbsoluteUri;
if (!string.IsNullOrWhiteSpace(_cdnUrl))
{
var cdnUriBuilder = new UriBuilder(_blobServiceClient.Uri.Scheme, _cdnUrl);
baseUrl = cdnUriBuilder.Uri.AbsoluteUri;
}
result = UrlHelperExtensions.Combine(baseUrl, EscapeUri(blobKey));
}
return(result);
}
public virtual async Task CreateFolderAsync(BlobFolder folder)
{
var path = folder.ParentUrl == null ?
folder.Name :
UrlHelperExtensions.Combine(folder.ParentUrl, folder.Name);
var containerName = GetContainerNameFromUrl(path);
var container = _blobServiceClient.GetBlobContainerClient(containerName);
await container.CreateIfNotExistsAsync(PublicAccessType.Blob);
var directoryPath = GetDirectoryPathFromUrl(path);
if (!string.IsNullOrEmpty(directoryPath))
{
//Need upload empty blob because azure blob storage not support direct directory creation
using var stream = new MemoryStream(new byte[0]);
await container.GetBlockBlobClient(directoryPath).UploadAsync(stream);
}
}
public virtual async Task <BlobEntrySearchResult> SearchAsync(string folderUrl, string keyword)
{
var result = AbstractTypeFactory <BlobEntrySearchResult> .TryCreateInstance();
if (!string.IsNullOrEmpty(folderUrl))
{
var container = GetBlobContainer(GetContainerNameFromUrl(folderUrl));
if (container != null)
{
var baseUriEscaped = EscapeUri(container.Uri.AbsoluteUri);
var prefix = GetDirectoryPathFromUrl(folderUrl);
if (!string.IsNullOrEmpty(keyword))
{
//Only whole container list allow search by prefix
prefix += keyword;
}
// Call the listing operation and return pages of the specified size.
var resultSegment = container.GetBlobsByHierarchyAsync(prefix: prefix, delimiter: Delimiter)
.AsPages();
// Enumerate the blobs returned for each page.
await foreach (var blobPage in resultSegment)
{
// A hierarchical listing may return both virtual directories and blobs.
foreach (var blobhierarchyItem in blobPage.Values)
{
if (blobhierarchyItem.IsPrefix)
{
var folder = AbstractTypeFactory <BlobFolder> .TryCreateInstance();
// No Unescaping for Name. Unescaping a string that has been previously unescaped can lead to ambiguities and errors.
folder.Name = blobhierarchyItem.Prefix
.Split(new[] { Delimiter }, StringSplitOptions.RemoveEmptyEntries)
.Last();
folder.Url = UrlHelperExtensions.Combine(baseUriEscaped, EscapeUri(blobhierarchyItem.Prefix));
folder.ParentUrl = GetParentUrl(baseUriEscaped, blobhierarchyItem.Prefix);
folder.RelativeUrl = folder.Url.Replace(EscapeUri(_blobServiceClient.Uri.ToString()), string.Empty);
result.Results.Add(folder);
}
else
{
var blobInfo = ConvertBlobToBlobInfo(blobhierarchyItem.Blob, baseUriEscaped);
//Do not return empty blob (created with directory because azure blob not support direct directory creation)
if (!string.IsNullOrEmpty(blobInfo.Name))
{
result.Results.Add(blobInfo);
}
}
}
}
}
}
else
{
// Call the listing operation and enumerate the result segment.
var resultSegment = _blobServiceClient.GetBlobContainersAsync().AsPages();
await foreach (var containerPage in resultSegment)
{
foreach (var item in containerPage.Values)
{
var folder = AbstractTypeFactory <BlobFolder> .TryCreateInstance();
folder.Name = item.Name.Split(Delimiter).Last();
folder.Url = EscapeUri(UrlHelperExtensions.Combine(_blobServiceClient.Uri.ToString(), item.Name));
result.Results.Add(folder);
}
}
}
result.TotalCount = result.Results.Count();
return(result);
}
