//------------------------------- Shared ------------------------------ /// <summary> /// Deletes file and thumbnail from azure storage /// </summary> /// <param name="fileName"> file to delete </param> /// <returns> no return </returns> public async Task DeleteBlobImage(string fileName) { BlobContainerClient container = new BlobContainerClient(Configuration["ImageBlob"], "images"); BlobClient blob = container.GetBlobClient(fileName); await blob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, default); blob = container.GetBlobClient($"{fileName}_thumb"); await blob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, default); }
/// <summary> /// Permamently delete job application and all connected resources. /// </summary> /// <param name="id"></param> /// <returns></returns> public async Task <IActionResult> Delete(int?id) { if (!id.HasValue) { return(BadRequest("id cannot be null")); } var jobApplication = await _context.JobApplications.FirstOrDefaultAsync(x => x.Id == id); string connectionString = _config.GetValue <string>("AzureBlob:ConnectionString"); // Get a reference to a container BlobContainerClient container = new BlobContainerClient(connectionString, "applications"); // Get a reference to a blob BlobClient blob = container.GetBlobClient(jobApplication.CvUrl); // Remove from AzureBlob _ = blob.DeleteIfExistsAsync(); // Remove from database _context.Remove(jobApplication); await _context.SaveChangesAsync(); return(RedirectToAction("Index", "JobApplication", new { Area = "User" })); }
public async Task <ActionResult> DeleteFile(int id) { var fileDetails = await _context.Files.FindAsync(id); if (fileDetails == null) { return(NotFound()); } _context.Files.Remove(fileDetails); await _context.SaveChangesAsync(); try { string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING"); BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString); string containerName = "files"; BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName); BlobClient blobClient = containerClient.GetBlobClient(fileDetails.Uri.Substring(fileDetails.Uri.LastIndexOf("/") + 1)); await blobClient.DeleteIfExistsAsync(); return(Ok()); } catch (Exception ex) { return(StatusCode(500, $"Internal sserver error: {ex}")); } }
public async Task <bool> DeleteBlobIfExistsAsync(string containerName, string blobName) { var blobClient = new BlobClient(this.ConnectionString, containerName, blobName); var deleteInfo = await blobClient.DeleteIfExistsAsync(); return(deleteInfo.Value); }
//TODO : Change this for filestream version public async Task <PackageUploadResult> UploadPackageAsync(string packageName, Stream fileStream, bool deleteIfExists = false) { string connectionString = ConnectionString; BlobContainerClient container = new BlobContainerClient(connectionString, "packagecontainer"); await container.CreateIfNotExistsAsync(); string blobName = packageName + ".zip"; BlobClient blob = container.GetBlobClient(blobName); if (!deleteIfExists && await blob.ExistsAsync()) { return(new PackageUploadResult { IsSuccess = false, ErrorMessage = $"Package name, {packageName} is already taken.", }); } if (deleteIfExists) { await blob.DeleteIfExistsAsync(); } await blob.UploadAsync(fileStream); return(new PackageUploadResult { IsSuccess = true, ErrorMessage = "", }); }
protected virtual async Task DeleteAsync(string fullPath, CancellationToken cancellationToken) { (BlobContainerClient container, string path) = await GetPartsAsync(fullPath, false).ConfigureAwait(false); if (StoragePath.IsRootPath(path)) { //deleting the entire container / filesystem await container.DeleteIfExistsAsync(cancellationToken : cancellationToken).ConfigureAwait(false); } else { BlockBlobClient blob = string.IsNullOrEmpty(path) ? null : container.GetBlockBlobClient(StoragePath.Normalize(path)); if (blob != null) { try { await blob.DeleteAsync( DeleteSnapshotsOption.IncludeSnapshots, cancellationToken : cancellationToken).ConfigureAwait(false); } catch (RequestFailedException ex) when(ex.ErrorCode == "BlobNotFound") { //this might be a folder reference, just try it await foreach (BlobItem recursedFile in container.GetBlobsAsync(prefix: path, cancellationToken: cancellationToken).ConfigureAwait(false)) { BlobClient client = container.GetBlobClient(recursedFile.Name); await client.DeleteIfExistsAsync(cancellationToken : cancellationToken).ConfigureAwait(false); } } } } }
public async Task <bool> DeletePhotoAsync(string fileName) { var client = new BlobClient(_settings.ConnectionString, _settings.ContainerName, fileName); var result = await client.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots); return(result.Value); }
public static async Task DeleteBlobAsync(string connectionString, string containerName, string name) { var blob = new BlobClient(connectionString, containerName, name); await blob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots); }
public async Task <bool> DeleteFileFromStorageContainer(string path) { BlobContainerClient containerClient = GetFileShareContainer(); BlobClient blobClient = containerClient.GetBlobClient(path); return(await blobClient.DeleteIfExistsAsync()); }
public async Task GlobalTearDown() { if (Mode != RecordedTestMode.Playback) { var configuration = TestConfigurations.DefaultTargetOAuthTenant; var containerClient = new BlobServiceClient( new Uri(Tenants.TestConfigOAuth.BlobServiceEndpoint), new StorageSharedKeyCredential(Tenants.TestConfigOAuth.AccountName, Tenants.TestConfigOAuth.AccountKey)) .GetBlobContainerClient(_containerName); await foreach (BlobItem blobItem in containerClient.GetBlobsAsync(BlobTraits.ImmutabilityPolicy | BlobTraits.LegalHold)) { BlobClient blobClient = containerClient.GetBlobClient(blobItem.Name); if (blobItem.Properties.HasLegalHold) { await blobClient.SetLegalHoldAsync(false); } if (blobItem.Properties.ImmutabilityPolicy.ExpiresOn != null) { await blobClient.DeleteImmutabilityPolicyAsync(); } await blobClient.DeleteIfExistsAsync(); } await _storageManagementClient.BlobContainers.DeleteAsync( resourceGroupName : configuration.ResourceGroupName, accountName : configuration.AccountName, containerName : _containerName); } }
private async Task <bool> DeleteIfExistsAsync(string org, string fileName) { BlobClient blockBlob = await CreateBlobClient(org, fileName); bool result = await blockBlob.DeleteIfExistsAsync(); return(result); }
public Task DeleteFile(string fileName) { NLogManager.LogInfo("Delete " + fileName); ReNameFile(fileName); BlobClient blob = _blobContainer.GetBlobClient(fileName); return(blob.DeleteIfExistsAsync()); }
public async Task <bool> DeleteFile(string blobName, bool isPublic = false) { BlobContainerClient container = this.GetContainer(isPublic); BlobClient blobClient = container.GetBlobClient(blobName); await blobClient.DeleteIfExistsAsync(); return(true); }
public async Task <IActionResult> DeleteItemAsync(string id) { _logger.LogInformation("Delete content for id {id}", id); string tableName = _appSettings.TableName; string tableConnectionString = _appSettings.TableConnectionString; string containerName = _appSettings.MediaStorageContainer; string storageConnectionString = _appSettings.MediaStorageConnectionString; // Initialize table client CloudStorageAccount storageAccount; storageAccount = CloudStorageAccount.Parse(tableConnectionString); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(new TableClientConfiguration()); CloudTable table = tableClient.GetTableReference(tableName); // Initialize blob container client BlobContainerClient blobContainerClient = new BlobContainerClient(storageConnectionString, containerName); string rowKey = id; TableOperation retrieveOperation = TableOperation.Retrieve <ImageEntity>(TransferPartitionKey, rowKey); TableResult result = await table.ExecuteAsync(retrieveOperation); ImageEntity entity = result.Result as ImageEntity; if (entity == null) { _logger.LogWarning("Item id {id} not found", id); return(NotFound()); } var blobUriBuilder = new BlobUriBuilder(new Uri(entity.FileURL)); BlobClient blobClient = blobContainerClient.GetBlobClient(blobUriBuilder.BlobName); await blobClient.DeleteIfExistsAsync(); blobUriBuilder = new BlobUriBuilder(new Uri(entity.ThumbnailURL)); blobClient = blobContainerClient.GetBlobClient(blobUriBuilder.BlobName); await blobClient.DeleteIfExistsAsync(); TableOperation deleteOperation = TableOperation.Delete(entity); result = await table.ExecuteAsync(deleteOperation); return(NoContent()); }
public async Task <bool> DeleteBlob(string blobRef) { BlobContainerClient container = await GetBlobContainerClient(); BlobClient blob = container.GetBlobClient(blobRef); return(await blob.DeleteIfExistsAsync()); }
public async Task <bool> DeleteAsync(string name) { BlobClient client = this.containerClient.GetBlobClient(name); Response <bool> response = await client.DeleteIfExistsAsync(); return(response.Value); }
/// <summary> /// Delete blob by Uri /// </summary> /// <param name="id">The Blob Uri</param> /// <returns></returns> public async Task DeleteBlob(string id) { var blobClient = new BlobClient(new Uri(id)); var containerName = blobClient.BlobContainerName; var blobName = blobClient.Name; blobClient = new BlobClient(_connectionString, containerName, blobName); await blobClient.DeleteIfExistsAsync(); }
public async Task <bool> DeleteModelBlob(string fileName) { string con = _config["BlobConnection"]; BlobServiceClient blobService = new BlobServiceClient(con); BlobContainerClient containerClient = blobService.GetBlobContainerClient("models"); BlobClient blobClient = containerClient.GetBlobClient(fileName); return(await blobClient.DeleteIfExistsAsync()); }
public async Task <bool> DeleteAsync(string path, CancellationToken cancellationToken = default) { var container = GetContainerName(path); var blobPath = GetPathWithoutContainer(path); var client = new BlobClient(_connectionString, container, blobPath); var res = await client.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, cancellationToken); return(res.Value); }
public async Task <bool> Handle(DeleteBlobCommandModel request, CancellationToken cancellationToken) { BlobContainerClient containerClient = _blobServiceClient.GetBlobContainerClient(request.ContainerName.ToLower()); BlobClient blobClient = containerClient.GetBlobClient(request.Name); Response <bool> isDeleted = await blobClient.DeleteIfExistsAsync(cancellationToken : cancellationToken); return(isDeleted); }
private static async Task <bool> DeleteIfExistsAsync(Uri blobUri, StorageSharedKeyCredential storageCredentials) { // Create the blob client. BlobClient blobClient = new BlobClient(blobUri, storageCredentials); // Delete the file var response = await blobClient.DeleteIfExistsAsync(); return(await Task.FromResult(response.Value)); }
public async Task <bool> Delete(string blobName) { BlobContainerClient container = new BlobContainerClient(settings.ConnectionString, settings.ContainerName); container.CreateIfNotExists(PublicAccessType.BlobContainer); BlobClient blobClient = container.GetBlobClient(blobName); await blobClient.DeleteIfExistsAsync(); return(true); }
public async Task <bool> DeleteBlob(string connectionString, string containerName, string blobName) { BlobContainerClient container = new BlobContainerClient(connectionString, containerName); // Get a reference to a blob named "sample-file" in a container named "sample-container" BlobClient blob = container.GetBlobClient(blobName); // Upload local file return(await blob.DeleteIfExistsAsync()); }
public static async Task UploadBlobAsync(string connectionString, string containerName, string fileName) { var file = new FileInfo(fileName); var blob = new BlobClient(connectionString, containerName, file.Name); await blob.DeleteIfExistsAsync(); await blob.UploadAsync(fileName); }
public static async Task DeleteBlobAsync(string connectionString, string containerName, string fileName) { CheckIsNotNullOrWhitespace(nameof(connectionString), connectionString); CheckIsNotNullOrWhitespace(nameof(containerName), containerName); CheckIsNotNullOrWhitespace(nameof(fileName), fileName); var blob = new BlobClient(connectionString, containerName, fileName); await blob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots); }
private async Task ClearHostIdInfoAsync() { string blobPath = string.Format(HostIdValidator.BlobPathFormat, _testHostId); BlobClient blobClient = _blobContainerClient.GetBlobClient(blobPath); await blobClient.DeleteIfExistsAsync(); await TestHelpers.Await(async() => { bool exists = await blobClient.ExistsAsync(); return(!exists); }); }
public async Task <bool> DeleteAsync(string fileName) { BlobClient blobClient = containerClient.GetBlobClient(fileName); if (blobClient == null) { return(false); } await blobClient.DeleteIfExistsAsync(); return(true); }
private async Task fDeleteFromBlobStorageAsync(string blobName) { var storageConn = _config.GetValue <string>("AppSettings:MyAzureStorageConnectionKey1"); // Get a reference to a Container BlobContainerClient blobContainerClient = new BlobContainerClient(storageConn, BlobContainerNAME); // Delete the file BlobClient blobClient = blobContainerClient.GetBlobClient(blobName); await blobClient.DeleteIfExistsAsync(); Console.WriteLine(blobName + ": file deleted successfully from azure blob storage..."); }
public async Task <bool> DeleteFile(string containerName, string fileName) { // Create the container if not exists and return a container client object BlobContainerClient containerClient = new BlobContainerClient(_connectionString, containerName); await containerClient.CreateIfNotExistsAsync(PublicAccessType.Blob); // Get a reference to a blob BlobClient blobClient = containerClient.GetBlobClient(fileName); // Delete the blob var response = await blobClient.DeleteIfExistsAsync(); return(response.Value); }
public async Task DeleteFileAsync(string containerName, string fileName) { BlobContainerClient containerClient; try { containerClient = await BlobServiceClient.CreateBlobContainerAsync(containerName); } catch { containerClient = BlobServiceClient.GetBlobContainerClient(containerName); } BlobClient blobClient = containerClient.GetBlobClient(fileName); await blobClient.DeleteIfExistsAsync(); }