public void AuthWithSasCredential() { //setup blob string containerName = Randomize("sample-container"); string blobName = Randomize("sample-file"); var container = new BlobContainerClient(ConnectionString, containerName); try { container.Create(); BlobClient blobClient = container.GetBlobClient(blobName); blobClient.Upload(BinaryData.FromString("hello world")); // build SAS URI for sample Uri sasUri = blobClient.GenerateSasUri(BlobSasPermissions.All, DateTimeOffset.UtcNow.AddHours(1)); #region Snippet:SampleSnippetsBlobMigration_SasUri BlobClient blob = new BlobClient(sasUri); #endregion var stream = new MemoryStream(); blob.DownloadTo(stream); Assert.Greater(stream.Length, 0); } finally { container.Delete(); } }
private static Uri GetSasUriForBlob(BlobClient blobClient, string storedPolicyName = null) { // Check whether this BlobClient object has been authorized with Shared Key. if (blobClient.CanGenerateSasUri) { // Create a SAS token that's valid for one hour. var sasBuilder = new BlobSasBuilder() { BlobContainerName = blobClient.GetParentBlobContainerClient().Name, BlobName = blobClient.Name, Resource = "b" }; if (storedPolicyName == null) { sasBuilder.ExpiresOn = DateTimeOffset.UtcNow.AddHours(1); sasBuilder.SetPermissions(BlobSasPermissions.Read | BlobSasPermissions.Write); } else { sasBuilder.Identifier = storedPolicyName; } var sasUri = blobClient.GenerateSasUri(sasBuilder); Console.WriteLine("SAS URI for blob is: {0}\n", sasUri); return(sasUri); } else { Console.WriteLine(@"BlobClient must be authorized with Shared Key credentials to create a service SAS."); return(null); } }
public string GetDownloadUrl(string fileName) { BlobClient blobClient = _containerClient.GetBlobClient(blobName: fileName); Uri uri = blobClient.GenerateSasUri(Azure.Storage.Sas.BlobSasPermissions.Read, DateTimeOffset.UtcNow.AddDays(1)); return(uri.ToString()); }
private static async Task <string> UploadFileAsync(string connectionString, string blobContainer, string storageId, string filePath) { BlobClient blob = new BlobClient( connectionString, blobContainer, storageId); if (!blob.CanGenerateSasUri) { throw new NotSupportedException("Blob container doesn't support SAS tokens"); } await blob.UploadAsync(filePath); BlobSasBuilder sasBuilder = new BlobSasBuilder() { BlobContainerName = blobContainer, BlobName = storageId, Resource = "b" }; sasBuilder.ExpiresOn = DateTimeOffset.UtcNow.AddDays(1); sasBuilder.SetPermissions(BlobAccountSasPermissions.Read); var sasUri = blob.GenerateSasUri(sasBuilder); return(sasUri.ToString()); }
private static void FillFileInfo(File file, BlobClient blob, BlobSasBuilder readPermissions) { file.FileId = blob.Name; file.FullName = blob.Name; string[] parts = blob.Name.Split('/'); int length = parts.Length; file.Name = parts[length - 1]; file.ObjectType = parts[0]; file.ObjectId = parts[1]; string sasUrl = null; if (readPermissions != null) { sasUrl = blob.GenerateSasUri(readPermissions).ToString(); } file.Url = sasUrl ?? blob.Uri.ToString(); if (!string.IsNullOrWhiteSpace(Settings.FileSecondaryUrl)) { file.SecondaryUrl = sasUrl == null ? $"{Settings.FileSecondaryUrl}{blob.Uri.AbsolutePath}" : $"{Settings.FileSecondaryUrl}{blob.Uri.AbsolutePath}?{sasUrl.Split('?')[1]}"; } }
// Create a SAS token for the source blob, to enable it to be read by the StartCopyFromUriAsync method private static Uri GetSharedAccessUri(string blobName, BlobContainerClient container) { DateTimeOffset expiredOn = DateTimeOffset.UtcNow.AddMinutes(60); BlobClient blob = container.GetBlobClient(blobName); Uri sasUri = blob.GenerateSasUri(BlobSasPermissions.Read, expiredOn); return(sasUri); }
public async Task SasBuilderIdentifier() { string accountName = StorageAccountName; string accountKey = StorageAccountKey; string containerName = Randomize("sample-container"); string blobName = Randomize("sample-blob"); DateTimeOffset expiresOn = DateTimeOffset.UtcNow.AddDays(1); DateTimeOffset startsOn = DateTimeOffset.UtcNow.AddHours(-1); StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(StorageAccountName, StorageAccountKey); // setup blob var container = new BlobContainerClient(ConnectionString, containerName); try { await container.CreateAsync(); BlobClient blobClient = container.GetBlobClient(blobName); await container.GetBlobClient(blobName).UploadAsync(BinaryData.FromString("hello world")); // Create one or more stored access policies. List <BlobSignedIdentifier> signedIdentifiers = new List <BlobSignedIdentifier> { new BlobSignedIdentifier { Id = "mysignedidentifier", AccessPolicy = new BlobAccessPolicy { StartsOn = startsOn, ExpiresOn = expiresOn, Permissions = "rw" } } }; // Set the container's access policy. await container.SetAccessPolicyAsync(permissions : signedIdentifiers); #region Snippet:SampleSnippetsBlobMigration_SasBuilderIdentifier // Create BlobSasBuilder and specify parameters BlobSasBuilder sasBuilder = new BlobSasBuilder { Identifier = "mysignedidentifier" }; #endregion // Create full, self-authenticating URI to the resource Uri sasUri = blobClient.GenerateSasUri(sasBuilder); // successful download indicates pass await new BlobClient(sasUri).DownloadToAsync(new MemoryStream()); } finally { await container.DeleteIfExistsAsync(); } }
public Uri GetSasUriForBlob(Uri uri) { var accuntName = _config["AppSettings:AzureAccountName"]; var key = _config["AppSettings:AzureAccountKey"]; StorageSharedKeyCredential storageCredentials = new StorageSharedKeyCredential(accuntName, key); // Create the blob client. BlobClient blobClient = new BlobClient(uri, storageCredentials); return(blobClient.GenerateSasUri(Azure.Storage.Sas.BlobSasPermissions.Read, DateTimeOffset.Now.AddHours(1))); }
public async Task <string> UploadFileAsync(string filePath, string container, string blobName, bool overwrite = false, CancellationToken cancellationToken = default) { BlobContainerClient containerClient = _blobClient.GetBlobContainerClient(container); // Create the container if it does not exist. await containerClient.CreateIfNotExistsAsync(cancellationToken : cancellationToken); await using var stream = File.OpenRead(filePath); BlobClient blobClient = containerClient.GetBlobClient(blobName); if (overwrite || !await blobClient.ExistsAsync(cancellationToken)) { await blobClient.UploadAsync(stream, overwrite, cancellationToken); } return(blobClient.GenerateSasUri(BlobSasPermissions.Read, DateTimeOffset.MaxValue).ToString()); }
public DownloadSasUriTest(TOptions options) : base(options) { _blobClient = BlobContainerClient.GetBlobClient("_blobName"); var sharedKeyBlobClient = new BlobClient(_blobClient.Uri, StorageSharedKeyCredential); if (sharedKeyBlobClient.CanGenerateSasUri) { SasUri = sharedKeyBlobClient.GenerateSasUri(BlobSasPermissions.Read, DateTimeOffset.UtcNow.AddDays(1)); } else { throw new InvalidOperationException(); } }
public async Task GenerateSas() { string accountName = StorageAccountName; string accountKey = StorageAccountKey; string containerName = Randomize("sample-container"); string blobName = Randomize("sample-blob"); StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(StorageAccountName, StorageAccountKey); // setup blob var container = new BlobContainerClient(ConnectionString, containerName); BlobUriBuilder uriBuilder = new BlobUriBuilder(container.Uri) { BlobName = blobName }; Uri blobUri = uriBuilder.ToUri(); try { await container.CreateAsync(); await container.GetBlobClient(blobName).UploadAsync(BinaryData.FromString("hello world")); #region Snippet:SampleSnippetsBlobMigration_GenerateSas // Create a BlobClient with a shared key credential BlobClient blobClient = new BlobClient(blobUri, sharedKeyCredential); Uri sasUri; // Ensure our client has the credentials required to generate a SAS if (blobClient.CanGenerateSasUri) { // Create full, self-authenticating URI to the resource from the BlobClient sasUri = blobClient.GenerateSasUri(BlobSasPermissions.Read, DateTimeOffset.UtcNow.AddHours(1)); // Use newly made as SAS URI to download the blob await new BlobClient(sasUri).DownloadToAsync(new MemoryStream()); } #endregion else { Assert.Fail("Unable to create SAS URI"); } } finally { await container.DeleteIfExistsAsync(); } }
public async Task GenerateSas_Builder() { string accountName = StorageAccountName; string accountKey = StorageAccountKey; string containerName = Randomize("sample-container"); string blobName = Randomize("sample-blob"); StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(StorageAccountName, StorageAccountKey); // setup blob var container = new BlobContainerClient(ConnectionString, containerName); BlobUriBuilder uriBuilder = new BlobUriBuilder(container.Uri) { BlobName = blobName }; Uri blobUri = uriBuilder.ToUri(); try { await container.CreateAsync(); await container.GetBlobClient(blobName).UploadAsync(BinaryData.FromString("hello world")); // Create a BlobClient with a shared key credential BlobClient blobClient = new BlobClient(blobUri, sharedKeyCredential); // Create BlobSasBuilder and specify parameters #region Snippet:SampleSnippetsBlobMigration_GenerateSas_Builder BlobSasBuilder sasBuilder = new BlobSasBuilder(BlobSasPermissions.Read, DateTimeOffset.UtcNow.AddHours(1)) { // Since we are generating from the client, the client will have the container and blob name // Specify any optional paremeters here StartsOn = DateTimeOffset.UtcNow.AddHours(-1) }; // Create full, self-authenticating URI to the resource from the BlobClient Uri sasUri = blobClient.GenerateSasUri(sasBuilder); #endregion // Use newly made as SAS URI to download the blob await new BlobClient(sasUri).DownloadToAsync(new MemoryStream()); } finally { await container.DeleteIfExistsAsync(); } }
private static Uri GenerateSasURL(string containername, string blobName, BlobContainerClient containerClient) { BlobClient _client = containerClient.GetBlobClient(blobName); BlobSasBuilder _builder = new BlobSasBuilder() { BlobContainerName = containername, BlobName = blobName, Resource = "b" }; _builder.SetPermissions(BlobAccountSasPermissions.Read | BlobAccountSasPermissions.List); _builder.ExpiresOn = DateTime.Now.AddHours(1); Uri sasURL = _client.GenerateSasUri(_builder); return(sasURL); }
/// <inheritdoc /> public string CreateSASUrl(string container, string objectName, int tokenDuration) { var blobClient = new BlobClient(_storageOptions.Value.StorageConnectionString, container, objectName); if (blobClient.CanGenerateSasUri) { var tokenBuilder = new BlobSasBuilder { BlobContainerName = container, BlobName = objectName, Resource = "b", ExpiresOn = DateTimeOffset.UtcNow.AddHours(1) }; tokenBuilder.SetPermissions(BlobSasPermissions.Read); return(blobClient.GenerateSasUri(tokenBuilder).ToString()); } _logger.LogError("Azure Connection String not authorized with enough permissions to create a SAS"); throw new InvalidOperationException("Azure Connection String doesn't support creating SAS URLs"); }
/// <summary> /// Returns a URI containing a SAS for the blob. /// </summary> /// <param name="container">A reference to the container.</param> /// <param name="blobName">A string containing the name of the blob.</param> /// <returns>A string containing the URI for the blob, with the SAS token appended.</returns> static Uri GetBlobSasUri(BlobContainerClient container, string blobName) { //Get a reference to a blob within the container. //Note that the blob may not exist yet, but a SAS can still be created for it. BlobClient blob = container.GetBlobClient(blobName); var policy = new BlobSasBuilder { BlobContainerName = container.Name, BlobName = blobName, Resource = "b", StartsOn = DateTimeOffset.UtcNow.AddHours(-1), ExpiresOn = DateTimeOffset.UtcNow.AddHours(1), }; policy.SetPermissions(BlobSasPermissions.All); Uri sasUri = blob.GenerateSasUri(policy); //Return the URI string for the blob, including the SAS token. return(sasUri); }
private static Uri GetServiceSasUriForBlob(ILogger log, BlobClient blobClient, string containerName, string blobName, string storedPolicyName = null) { // Check whether this BlobClient object has been authorized with Shared Key. log.LogInformation($"trying to get sas blobClient==null?{blobClient==null}. "); if (blobClient != null && blobClient.CanGenerateSasUri) { // Create a SAS token that's valid for one hour. BlobSasBuilder sasBuilder = new BlobSasBuilder() { BlobContainerName = containerName, BlobName = blobName, Resource = "b" }; if (storedPolicyName == null) { sasBuilder.ExpiresOn = DateTimeOffset.UtcNow.AddHours(1); sasBuilder.SetPermissions(BlobSasPermissions.Read | BlobSasPermissions.Write); } else { sasBuilder.Identifier = storedPolicyName; } Uri sasUri = blobClient.GenerateSasUri(sasBuilder); return(sasUri); } else { log.LogError("BlobClient must be authorized with Shared Key credentials to create a service SAS."); return(null); } }
static async Task Main(string[] args) { string connectionString = "CONNECTION_STRING"; string containerName = "fileuploadsample"; string blobFileName = "sample.png"; // Upload file to blob BlobContainerClient containerClient = new BlobContainerClient(connectionString, containerName); await containerClient.CreateIfNotExistsAsync(PublicAccessType.None); //Making blob private. BlobClient blobClient = new BlobClient(connectionString, containerName, blobFileName); using FileStream fileStream = File.OpenRead(blobFileName); await blobClient.UploadAsync(fileStream, true); fileStream.Close(); Console.WriteLine(blobClient.Uri.ToString()); // Generate SAS URI for blob BlobSasBuilder sasBuilder = new BlobSasBuilder() { BlobContainerName = containerClient.Name, Resource = "b", BlobName = blobClient.Name }; sasBuilder.ExpiresOn = DateTimeOffset.UtcNow.AddHours(1); sasBuilder.SetPermissions(BlobContainerSasPermissions.Read); if (blobClient.CanGenerateSasUri) { Uri blobSasUri = blobClient.GenerateSasUri(sasBuilder); Console.WriteLine(blobSasUri.ToString()); } Console.ReadLine(); }
protected override async Task <ZipResult> OnExecuteAsync(ZipRequest request) { var containerClient = new BlobContainerClient(_storageConnection, request.ContainerName); var pages = containerClient.GetBlobsAsync(prefix: request.BlobPrefix).AsPages(); const int maxFiles = 10; // to prevent runaway huge files. remember, this is just a little demo int count = 0; using (var outputStream = new MemoryStream()) { using (var outputZip = new ZipArchive(outputStream, ZipArchiveMode.Create, true)) { await foreach (var page in pages) { foreach (var blob in page.Values) { if (blob.Name.EndsWith(".zip")) { continue; // don't include other zip files } count++; if (count > maxFiles) { break; } var blobClient = new BlobClient(_storageConnection, request.ContainerName, blob.Name); using (var inputStream = await blobClient.OpenReadAsync()) { var entry = outputZip.CreateEntry(blob.Name); using (var entryStream = entry.Open()) { await inputStream.CopyToAsync(entryStream); } } } } } var outputBlobClient = new BlobClient(_storageConnection, request.ContainerName, StringId.New(8, StringIdRanges.Lower | StringIdRanges.Numeric) + ".zip"); outputStream.Position = 0; await outputBlobClient.UploadAsync(outputStream, new BlobUploadOptions() { HttpHeaders = new BlobHttpHeaders() { ContentType = "application/zip" } }); var expirationDate = DateTime.UtcNow.AddDays(3); var sasUri = outputBlobClient.GenerateSasUri(BlobSasPermissions.Read, expirationDate); return(new ZipResult() { Url = sasUri.ToString(), ExpiresAfter = expirationDate, BlobName = outputBlobClient.Name }); } }
public static async Task RunAsync([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log) { //Extracting content type and url of the blob triggering the function var jsondata = JsonConvert.SerializeObject(eventGridEvent.Data); var tmp = new { contentType = "", url = "" }; var data = JsonConvert.DeserializeAnonymousType(jsondata, tmp); //Checking if the trigger was iniatiated for a PDF File. if (data.contentType == "application/pdf") { var pdfUrl = data.url; string endpoint = System.Environment.GetEnvironmentVariable("FormsRecognizerEndpoint", EnvironmentVariableTarget.Process); string apiKey = System.Environment.GetEnvironmentVariable("FormsRecognizerKey", EnvironmentVariableTarget.Process); string contosoStorageConnectionString = System.Environment.GetEnvironmentVariable("ContosoStorageConnectionString", EnvironmentVariableTarget.Process); string cosmosEndpointUrl = System.Environment.GetEnvironmentVariable("CosmosDBEndpointUrl", EnvironmentVariableTarget.Process); string cosmosPrimaryKey = System.Environment.GetEnvironmentVariable("CosmosDBPrimaryKey", EnvironmentVariableTarget.Process); //Create a SAS Link to give Forms Recognizer read access to the document BlobServiceClient blobServiceClient = new BlobServiceClient(contosoStorageConnectionString); BlobContainerClient container = new BlobContainerClient(contosoStorageConnectionString, "claims"); string blobName = pdfUrl.Split('/').Last(); BlobClient blob = container.GetBlobClient(blobName); BlobSasBuilder sasBuilder = new BlobSasBuilder() { BlobContainerName = blob.GetParentBlobContainerClient().Name, BlobName = blob.Name, Resource = "b" }; sasBuilder.ExpiresOn = DateTimeOffset.UtcNow.AddHours(1); sasBuilder.SetPermissions(BlobSasPermissions.Read); Uri sasUri = blob.GenerateSasUri(sasBuilder); var credential = new AzureKeyCredential(apiKey); //Get the latest trained model var formTrainingClient = new FormTrainingClient(new Uri(endpoint), credential); Pageable <CustomFormModelInfo> formsModels = formTrainingClient.GetCustomModels(); var latestModel = (from inc in formsModels orderby inc.TrainingCompletedOn descending select inc).FirstOrDefault(); //TODO:Run the document through the model //Insert documents into CosmosDB var cosmosClient = new CosmosClient(cosmosEndpointUrl, cosmosPrimaryKey); var cosmosDatabase = (await cosmosClient.CreateDatabaseIfNotExistsAsync("Contoso")).Database; var cosmosContainer = (await cosmosDatabase.CreateContainerIfNotExistsAsync("Claims", "/InsuredID")).Container; Model.ClaimsDocument processedDocument = new Model.ClaimsDocument(); processedDocument.DocumentDate = new DateTime(int.Parse(blobName.Substring(0, 4)), int.Parse(blobName.Substring(4, 2)), int.Parse(blobName.Substring(6, 2))); processedDocument.PatientName = forms[0].Fields["PatientName"].ValueData?.Text; processedDocument.InsuredID = forms[0].Fields["InsuredID"].ValueData?.Text; processedDocument.Diagnosis = forms[0].Fields["Diagnosis"].ValueData?.Text; decimal.TryParse(forms[0].Fields["TotalCharges"].ValueData?.Text, out decimal totalCharges); processedDocument.TotalCharges = totalCharges; DateTime.TryParse(forms[0].Fields["PatientBirthDate"].ValueData?.Text, out DateTime patientBirthDate); processedDocument.PatientBirthDate = patientBirthDate; decimal.TryParse(forms[0].Fields["AmountPaid"].ValueData?.Text, out decimal amountPaid); processedDocument.AmountPaid = amountPaid; decimal.TryParse(forms[0].Fields["AmountDue"].ValueData?.Text, out decimal amountDue); processedDocument.AmountDue = amountDue; processedDocument.FileName = blobName; if (processedDocument.InsuredID == null) { processedDocument.Id = Guid.NewGuid().ToString(); } else { processedDocument.Id = processedDocument.InsuredID; } try { ItemResponse <Model.ClaimsDocument> cosmosResponse = await cosmosContainer.CreateItemAsync(processedDocument, new PartitionKey(processedDocument.InsuredID)); } catch (CosmosException ex) when(ex.StatusCode == System.Net.HttpStatusCode.Conflict) { //Conflicting EnsurerID is silently ignored for demo purposes. } } log.LogInformation(eventGridEvent.Data.ToString()); }
public async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req, ILogger log) { var isAuthorized = await Authenticator.AuthenticateRequestForScopeAndRole(req, "CMS.Articles.Edit", "Articles.Write", log); if (!isAuthorized) { return(new UnauthorizedResult()); } var articleId = req.Query["articleId"]; if (string.IsNullOrEmpty(articleId)) { log.LogError("GetImageUploadSasToken called without article ID"); return(new BadRequestObjectResult("articleId required")); } var fileName = req.Query["fileName"]; if (string.IsNullOrEmpty(articleId)) { log.LogError("GetImageUploadSasToken called without file name"); return(new BadRequestObjectResult("fileName required")); } var article = await CmsDb.GetArticleAsync(articleId); if (article == null) { log.LogError($"GetImageUploadSasToken called with unknown article ID: {articleId}"); return(new NotFoundObjectResult($"Article ID {articleId} not found.")); } log.LogInformation($"Getting SAS token for image upload {fileName} to article {articleId}."); var storageAccountName = Environment.GetEnvironmentVariable("ImageStorageAccountName"); var storageAccountKey = Environment.GetEnvironmentVariable("ImageStorageAccountKey"); var imagesContainerName = Environment.GetEnvironmentVariable("ImageStorageBlobContainerName"); var filePath = $"{articleId}/{fileName}"; var blobEndpoint = $"https://{storageAccountName}.blob.core.windows.net/{imagesContainerName}/{filePath}"; var storageCredential = new StorageSharedKeyCredential(storageAccountName, storageAccountKey); var blobClient = new BlobClient(new Uri(blobEndpoint), storageCredential); var sasBuilder = new BlobSasBuilder(BlobSasPermissions.Write | BlobSasPermissions.Create, DateTimeOffset.UtcNow.AddMinutes(30)); sasBuilder.BlobContainerName = blobClient.BlobContainerName; sasBuilder.BlobName = filePath; sasBuilder.Resource = "b"; sasBuilder.StartsOn = DateTimeOffset.UtcNow.AddMinutes(-5); var blobUri = blobClient.GenerateSasUri(sasBuilder); log.LogInformation($"Successfully created SAS token for image upload {fileName} to article {articleId}"); return(new OkObjectResult(blobUri.ToString())); }
public async Task <string> PublishFileAsync(FileMapping fileMap, CancellationToken ct) { Uri result = null; int retriesLeft = MaxFullLoopRetries; TimeSpan loopDelay = FullLoopRetryDelay; bool completed = false; do { _logger.LogInformation($"Attempting to publish {fileMap.RelativeOutputPath}, {retriesLeft} tries left."); try { BlobContainerClient client = await GetClient(ct); if (client == null) { // client creation failed, return return(null); } using var srcStream = new FileStream(fileMap.LocalSourcePath, FileMode.Open, FileAccess.Read); BlobClient blobClient = client.GetBlobClient(GetBlobName(_releaseName, fileMap.RelativeOutputPath)); await blobClient.UploadAsync(srcStream, overwrite : true, ct); BlobSasBuilder sasBuilder = new BlobSasBuilder() { BlobContainerName = client.Name, BlobName = blobClient.Name, Identifier = AccessPolicyDownloadId, Protocol = SasProtocol.Https }; Uri accessUri = blobClient.GenerateSasUri(sasBuilder); using BlobDownloadStreamingResult blobStream = (await blobClient.DownloadStreamingAsync(cancellationToken: ct)).Value; srcStream.Position = 0; completed = await VerifyFileStreamsMatchAsync(srcStream, blobStream, ct); result = accessUri; } catch (IOException ioEx) when(!(ioEx is PathTooLongException)) { _logger.LogWarning(ioEx, $"Failed to publish {fileMap.LocalSourcePath}, retries remaining: {retriesLeft}."); /* Retry IO exceptions */ retriesLeft--; loopDelay *= 2; if (retriesLeft > 0) { await Task.Delay(loopDelay, ct); } } catch (Exception ex) { // Azure errors have their own built-in retry logic, so just abort if we got an AzureResponseException _logger.LogWarning(ex, $"Failed to publish {fileMap.LocalSourcePath}, unexpected error, aborting."); return(null); } } while (retriesLeft > 0 && !completed); return(result?.OriginalString); }
private Uri GenerateSasUri(Uri bloUri) { var blobClient = new BlobClient(bloUri, _sharedKeyCredential); return(blobClient.GenerateSasUri(BlobSasPermissions.Read, DateTimeOffset.Now.AddSeconds(_sasTokenLifetimeSeconds))); }