public static async Task <string> UploadText(User entity)
{
BlobServiceClient blobServiceClient = new BlobServiceClient(Settings.storageConnectionString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(entity.name);
if (!containerClient.Exists())
{
containerClient = await blobServiceClient.CreateBlobContainerAsync(entity.name, PublicAccessType.BlobContainer);
}
//Get a container
string container = Guid.NewGuid().ToString();
BlobClient blobClient = containerClient.GetBlobClient(container);
int index = entity.dataUri.IndexOf(",") + 1;
string base64 = entity.dataUri.Substring(index);
var bytes = Convert.FromBase64String(base64);
using (var stream = new MemoryStream(bytes))
{
//cblob.UploadFromStream(stream);
await blobClient.UploadAsync(stream);
}
string FileURL = await new BlobStorage().getUriFromBlobAsync(entity.name, container);
if (string.IsNullOrEmpty(FileURL))
{
throw new Exception("FileURL is empty");
}
return(FileURL);
}
public async Task <string> UploadBlob(IFormFile Pixel)
{
string con = _config.GetSection("BlobStorageString").Value;
BlobServiceClient blobService = new BlobServiceClient(con);
//creates container to hold BLOBs.
//container name should NOT have any special characters or capitals!
BlobContainerClient containerClient = new BlobContainerClient("UseDevelopmentStorage=true", "pixel-arts");
//makes sure container exists
if (!containerClient.Exists())
{
await containerClient.CreateAsync();
await containerClient.SetAccessPolicyAsync(PublicAccessType.Blob);
}
//Add BLOB to container.
string newfileName = Guid.NewGuid().ToString() + Path.GetExtension(Pixel.FileName);
BlobClient blobClient = containerClient.GetBlobClient(newfileName);
await blobClient.UploadAsync(Pixel.OpenReadStream());
return(newfileName);
}
public CreatedID Create(ScriptCreate apiModel)
{
string scriptURL = null;
Script sc = _aviBL.GetScriptByPilotID(apiModel.PilotID);
if (sc != null)
{
scriptURL = sc.ScriptURL;
_aviBL.DeleteScriptIfExists(apiModel.PilotID);
}
_aviBL.DeleteScenesIfExists(apiModel.PilotID);
foreach (SceneCreate sceneApiModel in apiModel.Scenes)
{
sceneApiModel.PilotID = apiModel.PilotID;
_aviBL.AddScene(sceneApiModel.ToDLModel());
}
BlobContainerClient containerClient = _blobSC.GetBlobContainerClient($"pilot{apiModel.PilotID}");
if (!containerClient.Exists())
{
containerClient = _blobSC.CreateBlobContainer($"pilot{apiModel.PilotID}", Azure.Storage.Blobs.Models.PublicAccessType.BlobContainer);
}
else if (scriptURL != null)
{
containerClient.DeleteBlob(scriptURL.Substring(scriptURL.LastIndexOf('/') + 1));
}
BlobClient blobClient = containerClient.GetBlobClient($"script{Guid.NewGuid().ToString()}.html");
blobClient.Upload(GenerateStreamFromString(apiModel.ScriptBody));
apiModel.ScriptURL = blobClient.Uri.AbsoluteUri;
return(new CreatedID {
ID = _aviBL.AddScript(apiModel.ToDLModel()).ID
});
}
static async void SendToBlobAsync(string fileName, IntPtr buf, uint bufSize, BlobServiceClient blobServiceClient)
{
if (IntPtr.Zero != buf && bufSize > 0)
{
byte[] pic = new byte[bufSize];
Marshal.Copy(buf, pic, 0, (int)bufSize);
//unique name for the container
using (MemoryStream stream = new MemoryStream(pic))
{
try
{
// Create a BlobServiceClient object which will be used to create a container client
//BlobServiceClient blobServiceClient = new BlobServiceClient(StorageConnString);
//BlobServiceClient blobServiceClient = new BlobServiceClient(EdgeStorageConnString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(localContainerName);
if (!containerClient.Exists())
{
await blobServiceClient.CreateBlobContainerAsync(localContainerName);
}
BlobClient blobClient = containerClient.GetBlobClient(fileName);
await blobClient.UploadAsync(stream, true);
stream.Close();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
/// <summary>Check to see if a blob already exists in the specified container</summary>
/// <param name="containerName"></param>
/// <param name="blobName">File or blob name to check for</param>
/// <returns></returns>
/// <remarks>Remember to include a file extension</remarks>
public bool BlobExists(string containerName, string blobName)
{
// blob container name - can we set a default somehow
if (containerName == null || blobName == null)
{
throw new System.ArgumentNullException("Arguments can not be null.");
}
containerName = containerName.Trim();
blobName = blobName.Trim();
if (containerName == String.Empty || blobName == String.Empty)
{
return(false);
}
// Get a reference to a share and then create it
BlobContainerClient container = new BlobContainerClient(this.ConnectionString, containerName);
// check the container exists
Response <bool> exists = container.Exists();
if (!exists.Value)
{
return(false);
}
// Get a reference to the blob name
BlobClient blob = container.GetBlobClient(blobName);
exists = blob.Exists();
return(exists.Value);
}
private async Task <List <string> > GetThumbNailUrls()
{
List <string> thumbnailUrls = new();
// Create a URI to the storage account
Uri accountUri = new Uri("https://" + _storageConfig.AccountName + ".blob.core.windows.net/");
// Create BlobServiceClient from the account URI
BlobServiceClient blobServiceClient = new BlobServiceClient(accountUri);
// Get reference to the container
BlobContainerClient container = blobServiceClient.GetBlobContainerClient(_storageConfig.ThumbnailContainer);
if (container.Exists())
{
foreach (BlobItem blobItem in container.GetBlobs())
{
thumbnailUrls.Add(container.Uri + "/" + blobItem.Name);
}
}
else
{
_logger.LogWarning($"ThumbnailContainer: '{_storageConfig.ThumbnailContainer}' do not exist!");
}
return(await Task.FromResult(thumbnailUrls));
}
public static async Task <List <string> > GetThumbNailUrls(AzureStorageConfig _storageConfig, TokenAcquisitionTokenCredential tokenCredential, TelemetryClient telemetryClient, string pathBase)
{
List <string> thumbnailUrls = new List <string>();
// Create a URI to the storage account
Uri blobUri = new Uri(_storageConfig.FullAccountName);
BlobServiceClient blobServiceClient = new BlobServiceClient(blobUri, tokenCredential, null);
// Get reference to the container
BlobContainerClient container = blobServiceClient.GetBlobContainerClient(_storageConfig.ImageContainer);
if (container.Exists())
{
foreach (BlobItem blobItem in container.GetBlobs())
{
if (IsImage(blobItem.Name))
{
string imageUrl = string.Format("{0}api/images/thumbnail?ImageName={1}", pathBase, blobItem.Name);
thumbnailUrls.Add(imageUrl);
telemetryClient.TrackTrace("Found Thumbnail - " + imageUrl);
}
}
}
else
{
telemetryClient.TrackException(new ArgumentNullException(string.Format("Container {0} not found!", container.Name)));
container.CreateIfNotExists(PublicAccessType.None, null, null);
}
return(await Task.FromResult(thumbnailUrls));
}
private static IEnumerable <BlobItem> GetAllElements(BlobContainerClient container)
{
if (!container.Exists())
{
throw new ArgumentException($"The container {container.Uri} does not exists or is not public.");
}
var resultSegment = container.GetBlobs(BlobTraits.Metadata, BlobStates.None).AsPages(default, 1000);
/// <summary>Gets a blob from Azure Storage as just raw bytes with metadata</summary>
/// <param name="containerName">container name</param>
/// <param name="blobName">blob name</param>
/// <returns>Wrapped raw bytes with some metadata</returns>
public RawFileWrapper GetRawBlob(string containerName, string blobName)
{
RawFileWrapper results = new RawFileWrapper();
// validate input
if (String.IsNullOrWhiteSpace(containerName) || String.IsNullOrWhiteSpace(blobName))
{
return(results);
}
containerName = containerName.Trim();
blobName = blobName.Trim();
// Get a reference to a share and then create it
BlobContainerClient container = new BlobContainerClient(this.ConnectionString, containerName);
// check the container exists
Response <bool> exists = container.Exists();
if (!exists.Value)
{
return(results);
}
// set options
BlobOpenReadOptions op = new BlobOpenReadOptions(false);
// read the blob to an array
BlobClient blob = container.GetBlobClient(blobName);
using Stream stream = blob.OpenRead(op);
results.Data = new byte[stream.Length];
stream.Read(results.Data, 0, results.Data.Length);
stream.Close();
// get the properties
BlobProperties props = blob.GetProperties().Value;
if (props == null)
{
return(results);
}
results.ContentType = props.ContentType;
// get a filename
if (props.Metadata.ContainsKey("filename"))
{
results.Filename = props.Metadata["filename"].ToString();
}
else
{
results.Filename = blob.Name;
}
return(results);
}
public AzureFileStorage()
{
string connectionString = ConfigurationManager.AppSettings["AzureStorageConnectionString"];
blobServiceClient = new BlobServiceClient(connectionString);
containerClient = blobServiceClient.GetBlobContainerClient(ContainerName);
if (containerClient == null || !containerClient.Exists())
{
containerClient = blobServiceClient.CreateBlobContainer(ContainerName);
}
}
public void CreateContainer(string containerName)
{
BlobContainerClient containerClient = _blobServiceClient.GetBlobContainerClient(containerName);
if (containerClient.Exists())
{
throw new ApplicationException($"Unable to create container '{containerName}' as it already exists");
}
containerClient.Create();
}
public bool Method()
{
/* step 1 */
Console.WriteLine("Inside SomeClass.Method");
/* step 2 */
BlobContainerClient container = new BlobContainerClient("****connectionstring****", "code");
Console.WriteLine(container.Exists());
return(true);
}
public void DeleteContainer(string containerName)
{
BlobContainerClient containerClient = _blobServiceClient.GetBlobContainerClient(containerName);
if (!containerClient.Exists())
{
throw new ApplicationException($"Unable to delete container '{containerName}' as it does not exists");
}
containerClient.Delete();
}
private async Task <BlobContainerClient> CreateContainer()
{
var blobServiceClient = new BlobServiceClient(_config.AzureStorageConnectionString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(_config.ContainerName);
if (!containerClient.Exists())
{
await containerClient.CreateAsync();
}
return(containerClient);
}
public BlockBlobClient Create(string blobContainerName, string blobName)
{
var blobContainerClient = new BlobContainerClient(_blobStorageConfig.ConnectionString, blobContainerName);
if (!blobContainerClient.Exists())
{
blobContainerClient.CreateIfNotExists();
}
var blockBlobClient = new BlockBlobClient(_blobStorageConfig.ConnectionString, blobContainerName, blobName);
return(blockBlobClient);
}
public async Task <IActionResult> PostNewMap()
{
IFormFile postedFile = Request.Form.Files[0];
bool foundMapName = Request.Form.TryGetValue("mapName", out StringValues mapNameValues);
if (!foundMapName)
{
return(BadRequest());
}
string mapName = mapNameValues.AsEnumerable().First();
string currentUser = User.FindFirstValue(ClaimTypes.NameIdentifier);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(currentUser);
if (!containerClient.Exists())
{
containerClient = await blobServiceClient.CreateBlobContainerAsync(currentUser);
containerClient.SetAccessPolicy(PublicAccessType.BlobContainer);
}
BlobClient primaryBlobClient = containerClient.GetBlobClient(postedFile.FileName);
// Open the file and upload its data
using Stream uploadFileStream = postedFile.OpenReadStream();
await primaryBlobClient.UploadAsync(uploadFileStream, true);
uploadFileStream.Close();
Map map = new Map
{
CampaignID = _context.Campaigns.First(x => x.UserId == currentUser).CampaignID,
FileName = postedFile.FileName,
FilePath = primaryBlobClient.Uri.ToString(),
UserId = currentUser,
MapName = mapName,
};
bool foundNote = Request.Form.TryGetValue("noteId", out StringValues noteValues);
if (foundNote)
{
map = await LinkNewMapToNote(noteValues, map);
}
await _context.AddAsync(map);
await _context.SaveChangesAsync();
return(Ok());
}
public AsyncPageable <BlobItem> ListBlobs(string containerName)
{
blobServiceClient = new BlobServiceClient(STORAGE_CONNECTION_STRING);
blobContainerClient = blobServiceClient.GetBlobContainerClient(containerName);
if (blobContainerClient.Exists())
{
return(blobContainerClient.GetBlobsAsync());
}
else
{
throw new Exception("Container does not exists");
}
}
public void TestConnection()
{
try
{
if (_client.Exists(cancellationToken: _cancellationToken) == false)
{
throw new ContainerNotFoundException($"Container '{_storageContainer}' wasn't found!");
}
}
catch (UnauthorizedAccessException)
{
// we don't have the permissions to see if the container exists
}
}
public void UploadFile(string containerName, BlobFileData fileData, bool isPrivate)
{
var container = new BlobContainerClient(connectionString, containerName);
if (!container.Exists())
{
container.Create();
var accessType = isPrivate ? Azure.Storage.Blobs.Models.PublicAccessType.None : Azure.Storage.Blobs.Models.PublicAccessType.Blob;
container.SetAccessPolicy(accessType);
}
using (MemoryStream blobStream = new MemoryStream(fileData.Contents))
{
container.UploadBlob(fileData.Name, blobStream);
}
}
public BlobStorageService(string connectionString, string containerName)
{
try
{
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
_blobContainerClient = blobServiceClient.GetBlobContainerClient(containerName);
if (!_blobContainerClient.Exists())
{
throw new BlobContainerNotFoundException(containerName);
}
}
catch (Exception e) when(e is RequestFailedException || e is FormatException || e is AggregateException)
{
throw new InvalidBlobStorageConnectionStringException(connectionString);
}
}
private static async Task ClearBlobContainer(string containerName)
{
BlobContainerClient cloudBlobContainer = CreateBlobContainerClient(containerName);
if (!cloudBlobContainer.Exists())
{
return;
}
await foreach (BlobItem item in cloudBlobContainer.GetBlobsAsync())
{
Console.WriteLine(item.Name);
BlobClient cloudBlob = cloudBlobContainer.GetBlobClient(item.Name);
await cloudBlob.DeleteIfExistsAsync();
}
}
public static async Task <List <string> > GetThumbNailUrls(AzStorageConfig storageConfig)
{
List <string> thumbnailUrls = new List <string>();
Uri accountUri = new Uri(string.Format(storageConfig.AccountUri, storageConfig.AccountName));
BlobServiceClient blobServiceClient = new BlobServiceClient(accountUri);
BlobContainerClient container = blobServiceClient.GetBlobContainerClient(storageConfig.ThumbnailContainer);
if (container.Exists())
{
foreach (BlobItem blobItem in container.GetBlobs())
{
thumbnailUrls.Add($"{container.Uri}/{blobItem.Name}");
}
}
return(await Task.FromResult(thumbnailUrls));
}
public IActionResult Create([FromForm] FileCreate apiModel)
{
BlobContainerClient containerClient = _blobSC.GetBlobContainerClient($"pilot{apiModel.PilotID}");
if (!containerClient.Exists())
{
containerClient = _blobSC.CreateBlobContainer($"pilot{apiModel.PilotID}", Azure.Storage.Blobs.Models.PublicAccessType.BlobContainer);
}
BlobClient blobClient = containerClient.GetBlobClient(apiModel.FileName);
if (blobClient.Exists())
{
return(BadRequest(new { error = "File name already taken for this pilot" }));
}
blobClient.Upload(apiModel.File.OpenReadStream());
apiModel.FileURL = blobClient.Uri.AbsoluteUri;
return(Ok(FileMinimal.FromDLModel(_aviBL.AddFile(apiModel.ToDLModel()))));
}
private static string GenSASToken(string blobName)
{
// Create a URI to the storage account
Uri accountUri = new Uri("https://" + BLOB_STORAGE_NAME + ".blob.core.windows.net/");
// Create BlobServiceClient from the account URI
BlobServiceClient blobServiceClient = new BlobServiceClient(accountUri);
// Get reference to the container
BlobContainerClient container = blobServiceClient.GetBlobContainerClient(BLOB_STORAGE_CONTAINER);
string sasBlobUri = "";
if (container.Exists())
{
// Set the expiration time and permissions for the container.
// In this case, the start time is specified as a few
// minutes in the past, to mitigate clock skew.
// The shared access signature will be valid immediately.
BlobSasBuilder sas = new BlobSasBuilder
{
Resource = "c",
BlobContainerName = BLOB_STORAGE_CONTAINER,
StartsOn = DateTimeOffset.UtcNow.AddMinutes(-5),
ExpiresOn = DateTimeOffset.UtcNow.AddHours(BLOB_SAS_LENTGTH)
};
sas.SetPermissions(BlobContainerSasPermissions.All);
// Create StorageSharedKeyCredentials object by reading
// the values from the configuration (appsettings.json)
StorageSharedKeyCredential storageCredential =
new StorageSharedKeyCredential(BLOB_STORAGE_NAME, BLOB_STORAGE_KEY);
// Create a SAS URI to the storage account
UriBuilder sasUri = new UriBuilder(accountUri);
sasUri.Query = sas.ToSasQueryParameters(storageCredential).ToString();
// Create the URI using the SAS query token.
sasBlobUri = container.Uri + "/" + blobName + sasUri.Query;
}
return(sasBlobUri);
}
//-------------------------------------------------
// Create root container
//-------------------------------------------------
private static void CreateRootContainer(BlobServiceClient blobServiceClient)
{
try
{
// Create the root container or handle the exception if it already exists
BlobContainerClient container = blobServiceClient.CreateBlobContainer("$root");
if (container.Exists())
{
Console.WriteLine("Created root container.");
}
}
catch (RequestFailedException e)
{
Console.WriteLine("HTTP error code {0}: {1}",
e.Status, e.ErrorCode);
Console.WriteLine(e.Message);
}
}
/// <summary>Get a list of All blobs in the specified contaier</summary>
/// <param name="containerName">container name</param>
/// <returns>A list of blob names</returns>
/// <remarks>Still need to determine what we need back for each blob</remarks>
public List <string> ListBlobs(string containerName, string pattern = null)
{
List <string> blobs = new List <string>();
// blob container name - can we set a default somehow
if (String.IsNullOrWhiteSpace(containerName))
{
return(new List <string>());
}
// Get a reference to a share and then create it
BlobContainerClient container = new BlobContainerClient(this.ConnectionString, containerName);
// check the container exists
Response <bool> exists = container.Exists();
if (!exists.Value)
{
return(new List <string>());
}
Pageable <BlobItem> results = null;
if (String.IsNullOrWhiteSpace(pattern))
{
results = container.GetBlobs();
}
else
{
results = container.GetBlobs(prefix: pattern.Trim());
}
IEnumerator <BlobItem> enu = results?.GetEnumerator();
while (enu.MoveNext())
{
blobs.Add(enu.Current.Name);
}
;
return(blobs);
}
public static Task <BlobContainerClient> CreateContainerAsync(BlobServiceClient blobServiceClient, string containerName)
{
var newContainerName = _container + containerName;
try
{
BlobContainerClient container = blobServiceClient.CreateBlobContainer(containerName);
if (container.Exists())
{
return(Task.FromResult(container));
}
}
catch (RequestFailedException e)
{
// TODO: Logging in here.
Console.WriteLine("HTTP error code {0}: {1}", e.Status, e.ErrorCode);
Console.WriteLine(e.Message);
}
return(null);
}
private async Task <string> UploadWikiImage(WikiPage wikiPage)
{
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(wikiPage.UserId);
if (!containerClient.Exists())
{
containerClient = await blobServiceClient.CreateBlobContainerAsync(wikiPage.UserId);
containerClient.SetAccessPolicy(PublicAccessType.BlobContainer);
}
BlobClient primaryBlobClient = containerClient.GetBlobClient(wikiPage.PageName);
// Open the file and upload its data
using Stream uploadFileStream = wikiPage.ImageFile.OpenReadStream();
await primaryBlobClient.UploadAsync(uploadFileStream, true);
uploadFileStream.Close();
return(primaryBlobClient.Uri.ToString());
}
public async Task OnGetAsync()
{
try
{
var blobContainerClient = new BlobContainerClient(ContainerUri, new DefaultAzureCredential());
if (!blobContainerClient.Exists())
{
Blobs = Enumerable.Empty <BlobModel>();
}
else
{
Blobs = await blobContainerClient.GetBlobsAsync()
.Select(b => new BlobModel(b.Name))
.ToListAsync();
}
}
catch (Exception e)
{
ErrorMessage = e.Message;
}
}
//
//
// **** Cmdlet start ****
//
//
protected override void ProcessRecord()
{
//var cred = new ManagedIdentityCredential(identity);
//var containerClient = new BlobContainerClient(new Uri(container), cred);
var cred = new ManagedIdentityCredential(Identity);
var containerClient = new BlobContainerClient(new Uri(Container), cred);
if (containerClient.Exists())
{
WriteVerbose("Trying to read container...");
List <string> blobsListing = containerClient.GetBlobs().Select(i => i.Name).ToList();
WriteVerbose($"Obtained {blobsListing.Count} blobs");
blobsListing.ForEach(b => WriteObject(b));
}
else
{
//WriteVerbose($"Container {container} does not exist or cannot be accessed.");
WriteVerbose($"Container {Container} does not exist or cannot be accessed.");
// switch to error
// https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/adding-non-terminating-error-reporting-to-your-cmdlet?view=powershell-7.1#reporting-nonterminating-errors
}
}
