public async Task CreateDeleteImmutabilityPolicy()
{
// create a blob container
string containerName = Recording.GenerateAssetName("testblob");
BlobContainerData data = new BlobContainerData();
BlobContainer container = (await _blobContainerCollection.CreateOrUpdateAsync(containerName, new BlobContainerData())).Value;
//create immutability policy
ImmutabilityPolicyData immutabilityPolicyModel = new ImmutabilityPolicyData()
{
ImmutabilityPeriodSinceCreationInDays = 3
};
ImmutabilityPolicy immutabilityPolicy = (await container.GetImmutabilityPolicy().CreateOrUpdateAsync(parameters: immutabilityPolicyModel)).Value;
//validate
Assert.NotNull(immutabilityPolicy.Data.Id);
Assert.NotNull(immutabilityPolicy.Data.Type);
Assert.NotNull(immutabilityPolicy.Data.Name);
Assert.AreEqual(3, immutabilityPolicy.Data.ImmutabilityPeriodSinceCreationInDays);
Assert.AreEqual(ImmutabilityPolicyState.Unlocked, immutabilityPolicy.Data.State);
//delete immutability policy
immutabilityPolicyModel = (await immutabilityPolicy.DeleteAsync(immutabilityPolicy.Data.Etag)).Value;
//validate
Assert.NotNull(immutabilityPolicyModel.Type);
Assert.NotNull(immutabilityPolicyModel.Name);
Assert.AreEqual(0, immutabilityPolicyModel.ImmutabilityPeriodSinceCreationInDays);
}
internal bool GetBlobContentsWithoutInitialization(string blobName, Stream outputStream, out BlobProperties properties)
{
Debug.Assert(outputStream != null);
BlobContainer container = GetContainer();
try
{
properties = container.GetBlob(blobName, new BlobContents(outputStream), false);
Log.Write(EventKind.Information, "Getting contents of blob {0}", _info.BaseUri + _PathSeparator + _containerName + _PathSeparator + blobName);
return(true);
}
catch (StorageClientException sc)
{
if (sc.ErrorCode == StorageErrorCode.ResourceNotFound || sc.ErrorCode == StorageErrorCode.BlobNotFound)
{
properties = null;
return(false);
}
else
{
throw;
}
}
}
private BlobContainer GetContainer()
{
// we have to make sure that only one thread tries to create the container
lock (_lock)
{
if (_container != null)
{
return(_container);
}
try
{
BlobContainer container = BlobStorage.Create(_info).GetBlobContainer(_containerName);
container.Timeout = _Timeout;
container.RetryPolicy = _RetryPolicy;
container.CreateContainer();
_container = container;
return(_container);
}
catch (StorageException se)
{
Log.Write(EventKind.Error, "Error creating container {0}: {1}", ContainerUrl, se.Message);
throw;
}
}
}
/// <summary>
/// Saves the image by URL.
/// </summary>
/// <param name="externalUrl">The external URL.</param>
/// <param name="container">The container.</param>
/// <returns>Task{System.String}.</returns>
public async Task <OperationResult> SaveImageByUrl(string externalUrl, BlobContainer container)
{
var info = BlobInfo.GetInfoByUrl(externalUrl);
var uniqueName = GetUniqueImageName(info.Extension);
var webRequest = WebRequest.Create(externalUrl);
using (var response = await webRequest.GetResponseAsync())
{
using (var content = response.GetResponseStream())
{
if (content == null)
{
return(new OperationResult(
OperationResultStatus.Warning,
"Content of specified source is empty"));
}
var contentType = response.ContentType;
var manager = GetManager(container);
if (manager == null)
{
return(new OperationResult(OperationResultStatus.Warning, "Incorrect input"));
}
var url = await manager.AddBlockBlob(uniqueName, content, contentType);
return(new OperationResult(OperationResultStatus.Success, url));
}
}
}
internal async Task SaveImagesToProductionBlobOnUpdate(
List <string> oldUrls,
List <string> newUrls,
BlobContainer container)
{
var anyOldUrls = oldUrls.AnyValues();
var anyNewUrls = newUrls.AnyValues();
var notTouch =
anyOldUrls && anyNewUrls
? oldUrls.Intersect(newUrls).ToIList()
: new List <string>();
if (anyOldUrls)
{
foreach (var oldUrl in oldUrls)
{
if (!notTouch.Contains(oldUrl))
{
await DeleteImage(oldUrl);
}
}
}
if (anyNewUrls)
{
foreach (var newUrl in newUrls)
{
if (!notTouch.Contains(newUrl))
{
await SaveImageToProductionBlobOnAdd(newUrl, container);
}
}
}
}
public async Task GetAllBlobContainers()
{
//create two blob containers
string containerName1 = Recording.GenerateAssetName("testblob1");
string containerName2 = Recording.GenerateAssetName("testblob2");
BlobContainer container1 = (await _blobContainerCollection.CreateOrUpdateAsync(containerName1, new BlobContainerData())).Value;
BlobContainer container2 = (await _blobContainerCollection.CreateOrUpdateAsync(containerName2, new BlobContainerData())).Value;
//validate if there are two containers
BlobContainer container3 = null;
BlobContainer container4 = null;
int count = 0;
await foreach (BlobContainer container in _blobContainerCollection.GetAllAsync())
{
count++;
if (container.Id.Name == containerName1)
{
container3 = container;
}
if (container.Id.Name == containerName2)
{
container4 = container;
}
}
Assert.AreEqual(count, 2);
Assert.IsNotNull(container3);
Assert.IsNotNull(container4);
}
public async Task <BlobContainer> CreateContainer(BlobContainer container)
{
var blobServiceClient = new BlobServiceClient(_connectionString);
var publicAcessType = PublicAccessType.None;
if (container.Metadata?.Any(x => x.Key == "PublicAccessType") == true)
{
publicAcessType = Enum.Parse <PublicAccessType>(container.Metadata["PublicAccessType"].ToString());
}
IDictionary <string, string> metadata = null;
if ((container.Metadata?.Count > 0) == true)
{
metadata = new Dictionary <string, string>();
foreach (var prop in container.Metadata)
{
if (prop.Key != "PublicAccessType")
{
metadata.Add(prop.Key, prop.Value.ToString());
}
}
}
var response = (await blobServiceClient.CreateBlobContainerAsync(container.Identifier, publicAcessType, metadata)).Value;
return(ConstructContainer(response));
}
/// <summary>
/// Put (create or update) a blob from a memory stream.
/// </summary>
/// <param name="stream">Memory stream to put to a blob</param>
/// <param name="blobPath">Path to the blob</param>
/// <param name="contentType">Content type of the blob</param>
/// <param name="permissions">Blob Container Permissions for the blob</param>
/// <returns></returns>
public string PutBlob(MemoryStream stream, string blobPath, string contentType, BlobContainerPermissions permissions)
{
try
{
var blob = BlobContainer.GetBlockBlobReference(blobPath);
// Set proper content type on the blog
blob.Properties.ContentType = contentType;
// Set the permissions for the file to be accessible through the internet
BlobContainer.SetPermissions(permissions);
// Upload to the Blob
blob.UploadFromStream(stream);
return(blob.Uri.ToString());
}
catch (StorageException ex)
{
if (ex.RequestInformation.HttpStatusCode == 404)
{
return(string.Empty);
}
throw;
}
}
public static BlobContainer GetAzureContainer(string containerName)
{
StorageAccountInfo accountInfo = StorageAccountInfo.GetAccountInfoFromConfiguration("BlobStorageEndpoint");
BlobStorage blobStorage = BlobStorage.Create(accountInfo);
//The default timeout of 30 seconds is far too short, make it 6 hours.
blobStorage.Timeout = new TimeSpan(6, 0, 0);
if (String.IsNullOrEmpty(containerName))
{
// Default name for new container; Container names have the same restrictions as DNS names
containerName = String.Format("media{0}{1}", DateTime.Now.Year, DateTime.Now.DayOfYear);
}
else
{
//We have received a path from a media file
containerName = containerName.Substring(0, containerName.IndexOf("/"));
}
BlobContainer container = blobStorage.GetBlobContainer(containerName);
//If the Container already exists, false is returned, so go get it
if (!container.DoesContainerExist())
{
container.CreateContainer(null, ContainerAccessControl.Private);
}
return(container);
}
public AppLeaseManager(
AzureStorageClient azureStorageClient,
IPartitionManager partitionManager,
string appLeaseContainerName,
string appLeaseInfoBlobName,
AppLeaseOptions options)
{
this.azureStorageClient = azureStorageClient;
this.partitionManager = partitionManager;
this.appLeaseContainerName = appLeaseContainerName;
this.appLeaseInfoBlobName = appLeaseInfoBlobName;
this.options = options;
this.storageAccountName = this.azureStorageClient.BlobAccountName;
this.settings = this.azureStorageClient.Settings;
this.taskHub = settings.TaskHubName;
this.workerName = settings.WorkerId;
this.appName = settings.AppName;
this.appLeaseIsEnabled = this.settings.UseAppLease;
this.appLeaseContainer = this.azureStorageClient.GetBlobContainerReference(this.appLeaseContainerName);
this.appLeaseInfoBlob = this.appLeaseContainer.GetBlobReference(this.appLeaseInfoBlobName);
var appNameHashInBytes = BitConverter.GetBytes(Fnv1aHashHelper.ComputeHash(this.appName));
Array.Resize(ref appNameHashInBytes, 16);
this.appLeaseId = new Guid(appNameHashInBytes).ToString();
this.isLeaseOwner = false;
this.shutdownCompletedEvent = new AsyncManualResetEvent();
}
/// <summary>Returns an array of strings, one for each file in the directory. </summary>
public override string[] ListAll()
{
var results = from blob in BlobContainer.ListBlobs()
select blob.Uri.AbsolutePath.Substring(blob.Uri.AbsolutePath.LastIndexOf('/') + 1);
return(results.ToArray());
}
/// <summary>Removes an existing file in the directory. </summary>
public override void DeleteFile(string name)
{
var blobName = GetBlobName(name);
var blob = BlobContainer.GetBlockBlobReference(blobName);
blob.DeleteIfExists();
}
public async Task <IActionResult> GetAttachmentData(string chatId, string attachmentId)
{
var isMember = Database.CreateStatement <bool>($@"return (FOR u in 1..1 OUTBOUND 'Chat/{chatId}'
GRAPH 'ChatsUsersGraph'
PRUNE u._key == '{HttpContext.User.Identity.Name}'
FILTER u._key == '{HttpContext.User.Identity.Name}'
return u) != []").ToList().FirstOr(false);
if (!isMember)
{
return(NotFound());
}
var blob = BlobContainer.GetBlockBlobReference($"chats/{chatId}/{attachmentId}");
if (!await blob.ExistsAsync())
{
return(NotFound());
}
var sasConstraints = new SharedAccessBlobPolicy
{
SharedAccessStartTime = DateTime.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTime.UtcNow.AddHours(2),
Permissions = SharedAccessBlobPermissions.Read
};
var sasBlobToken = blob.GetSharedAccessSignature(sasConstraints);
return(Ok(new
{
Url = blob.Uri + sasBlobToken,
Mime = blob.Properties.ContentType
}));
}
public async Task BlobContainerEncryptionScope()
{
//create encryption scope
string scopeName1 = "testscope1";
string scopeName2 = "testscope2";
EncryptionScopeData data = new EncryptionScopeData()
{
Source = EncryptionScopeSource.MicrosoftStorage,
State = EncryptionScopeState.Enabled
};
await _storageAccount.GetEncryptionScopes().CreateOrUpdateAsync(true, scopeName1, data);
await _storageAccount.GetEncryptionScopes().CreateOrUpdateAsync(true, scopeName2, data);
//create container
string containerName = Recording.GenerateAssetName("container");
BlobContainer blobContainer = (await _blobContainerCollection.CreateOrUpdateAsync(true, containerName, new BlobContainerData()
{
DefaultEncryptionScope = scopeName1, DenyEncryptionScopeOverride = false
})).Value;
Assert.AreEqual(scopeName1, blobContainer.Data.DefaultEncryptionScope);
Assert.False(blobContainer.Data.DenyEncryptionScopeOverride.Value);
//Update container not support Encryption scope
BlobContainer blobContainer2 = (await _blobContainerCollection.CreateOrUpdateAsync(true, containerName, new BlobContainerData()
{
DefaultEncryptionScope = scopeName2, DenyEncryptionScopeOverride = true
})).Value;
Assert.AreEqual(scopeName2, blobContainer2.Data.DefaultEncryptionScope);
Assert.True(blobContainer2.Data.DenyEncryptionScopeOverride.Value);
}
public async Task SetClearLegalHold()
{
// create a blob container
string containerName = Recording.GenerateAssetName("testblob");
BlobContainerData data = new BlobContainerData();
BlobContainer container = (await _blobContainerCollection.CreateOrUpdateAsync(containerName, new BlobContainerData())).Value;
//set legal hold
LegalHold legalHoldModel = new LegalHold(new List <string> {
"tag1", "tag2", "tag3"
});
LegalHold legalHold = await container.SetLegalHoldAsync(legalHoldModel);
//validate
Assert.True(legalHold.HasLegalHold);
Assert.AreEqual(new List <string> {
"tag1", "tag2", "tag3"
}, legalHold.Tags);
//clear legal hold
legalHold = await container.ClearLegalHoldAsync(legalHoldModel);
//validate
Assert.False(legalHold.HasLegalHold);
Assert.AreEqual(0, legalHold.Tags.Count);
}
public void Name()
{
var container = new BlobContainer("container");
Assert.Equal("container", container.Name);
Assert.Equal("container", container.EmulatedName);
}
public async Task CreateDeleteBlobContainer()
{
//create blob container
string containerName = Recording.GenerateAssetName("testblob");
BlobContainer container1 = (await _blobContainerCollection.CreateOrUpdateAsync(containerName, new BlobContainerData())).Value;
Assert.IsNotNull(container1);
Assert.AreEqual(container1.Id.Name, containerName);
//validate if created successfully
BlobContainer container2 = await _blobContainerCollection.GetAsync(containerName);
AssertBlobContainerEqual(container1, container2);
Assert.IsTrue(await _blobContainerCollection.CheckIfExistsAsync(containerName));
Assert.IsFalse(await _blobContainerCollection.CheckIfExistsAsync(containerName + "1"));
BlobContainerData containerData = container1.Data;
Assert.IsEmpty(containerData.Metadata);
Assert.IsFalse(containerData.HasLegalHold);
Assert.IsNull(containerData.PublicAccess);
Assert.False(containerData.HasImmutabilityPolicy);
//delete blob container
BlobContainerDeleteOperation blobContainerDeleteOperation = await container1.DeleteAsync();
await blobContainerDeleteOperation.WaitForCompletionResponseAsync();
//validate if deleted successfully
BlobContainer blobContainer3 = await _blobContainerCollection.GetIfExistsAsync(containerName);
Assert.IsNull(blobContainer3);
Assert.IsFalse(await _blobContainerCollection.CheckIfExistsAsync(containerName));
}
public void DeleteFile(BlobContainer container, string resource)
{
var blobContainer = GetContainer(container);
CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(resource);
blockBlob.Delete();
}
public PSContainer(BlobContainer container)
{
this.ResourceGroupName = ParseResourceGroupFromId(container.Id);
this.StorageAccountName = ParseStorageAccountNameFromId(container.Id);
this.Id = container.Id;
this.Name = container.Name;
this.Type = container.Type;
this.Metadata = container.Metadata;
this.Etag = container.Etag;
this.PublicAccess = (PSPublicAccess?)container.PublicAccess;
this.ImmutabilityPolicy = container.ImmutabilityPolicy == null? null : new PSImmutabilityPolicyProperties(container.ImmutabilityPolicy);
this.LegalHold = container.LegalHold == null ? null : new PSLegalHoldProperties(container.LegalHold);
this.LastModifiedTime = container.LastModifiedTime;
this.LeaseStatus = container.LeaseStatus;
this.LeaseState = container.LeaseState;
this.LeaseDuration = container.LeaseDuration;
this.HasLegalHold = container.HasLegalHold;
this.HasImmutabilityPolicy = container.HasImmutabilityPolicy;
this.DefaultEncryptionScope = container.DefaultEncryptionScope;
this.DenyEncryptionScopeOverride = container.DenyEncryptionScopeOverride;
this.Deleted = container.Deleted;
this.RemainingRetentionDays = container.RemainingRetentionDays;
this.DeletedTime = container.DeletedTime;
this.Version = container.Version;
}
public async Task <SlideShowPictureDto> GetAsync(string name)
{
if (string.IsNullOrEmpty(name) || string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException();
}
var buffer = await BlobContainer.GetAllBytesOrNullAsync(name) ?? throw new FileNotFoundException();
var xmlStr = Encoding.UTF8.GetString(buffer);
var xmlDoc = CreateXmlDoc();
xmlDoc.LoadXml(xmlStr);
var slideShowElm = xmlDoc.DocumentElement;
var imgElm = slideShowElm.FirstChild;
var b64txtNode = imgElm.FirstChild as XmlText;
var imgTypeAttr = imgElm.Attributes.Item(0);
if (imgTypeAttr.LocalName != "imgType")
{
throw new Exception();
}
var dto = new SlideShowPictureDto {
Name = slideShowElm.GetAttribute("name"),
Uri = slideShowElm.GetAttribute("uri"),
Base64Picture = SetB64ImgContentType(b64txtNode.InnerText, imgTypeAttr.InnerText),
FileName = name
};
return(dto);
}
protected async Task<CloudBlobContainer> GetContainer(BlobContainer container)
{
var blobContainer = _blobClient.GetContainerReference(container.ToString().ToLower());
await blobContainer.CreateIfNotExistsAsync();
return blobContainer;
}
public async Task <SlideShowPictureDto> UpdateAsync(string fileName, SlideShowPictureDto dto)
{
if (string.IsNullOrWhiteSpace(fileName) ||
!ImageManipulator.IsImageStream(dto.Base64Picture))
{
throw new ArgumentException();
}
var b64Part = (dto.Base64Picture == null)? null : GetBase64Part(dto.Base64Picture);
var file = await BlobContainer.GetAllBytesOrNullAsync(fileName) ?? throw new FileNotFoundException();
var xmlDoc = new XmlDocument();
var settings = GetReaderSettings();
using var ms = new MemoryStream(file);
using var reader = XmlReader.Create(ms, settings);
xmlDoc.Load(reader);
var slideShowElm = xmlDoc.DocumentElement;
var imgElm = slideShowElm.FirstChild;
var b64txtNode = imgElm.FirstChild as XmlText;
b64txtNode.InnerText = b64Part ?? b64txtNode.InnerText;
slideShowElm.SetAttribute("uri", (dto.Uri == null) ? slideShowElm.GetAttribute("uri") : dto.Uri.ToString());
slideShowElm.SetAttribute("name", dto.Name ?? slideShowElm.GetAttribute("name"));
var bytes = Encoding.UTF8.GetBytes(xmlDoc.InnerXml);
await BlobContainer.SaveAsync(fileName, bytes, true);
return(await GetAsync(fileName));
}
public virtual async Task <string> SaveBytesAsync(string name, byte[] bytes)
{
var fileName = BlobPrefix + name;
await BlobContainer.SaveAsync(fileName, bytes);
return(fileName);
}
public void BlobContainersExtendImmutabilityPolicyTest()
{
var handler = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var resourcesClient = StorageManagementTestUtilities.GetResourceManagementClient(context, handler);
var storageMgmtClient = StorageManagementTestUtilities.GetStorageManagementClient(context, handler);
// Create resource group
var rgName = StorageManagementTestUtilities.CreateResourceGroup(resourcesClient);
// Create storage account
string accountName = TestUtilities.GenerateName("sto");
var parameters = StorageManagementTestUtilities.GetDefaultStorageAccountParameters();
parameters.Kind = Kind.StorageV2;
var account = storageMgmtClient.StorageAccounts.Create(rgName, accountName, parameters);
StorageManagementTestUtilities.VerifyAccountProperties(account, false);
// implement case
try
{
string containerName = TestUtilities.GenerateName("container");
BlobContainer blobContainer = storageMgmtClient.BlobContainers.Create(rgName, accountName, containerName);
Assert.Null(blobContainer.Metadata);
Assert.Null(blobContainer.PublicAccess);
ImmutabilityPolicy immutabilityPolicy = storageMgmtClient.BlobContainers.CreateOrUpdateImmutabilityPolicy(rgName, accountName, containerName, ifMatch: "", immutabilityPeriodSinceCreationInDays: 3);
Assert.NotNull(immutabilityPolicy.Id);
Assert.NotNull(immutabilityPolicy.Type);
Assert.NotNull(immutabilityPolicy.Name);
Assert.Equal(3, immutabilityPolicy.ImmutabilityPeriodSinceCreationInDays);
Assert.Equal(ImmutabilityPolicyState.Unlocked, immutabilityPolicy.State);
immutabilityPolicy = storageMgmtClient.BlobContainers.LockImmutabilityPolicy(rgName, accountName, containerName, ifMatch: immutabilityPolicy.Etag);
Assert.NotNull(immutabilityPolicy.Id);
Assert.NotNull(immutabilityPolicy.Type);
Assert.NotNull(immutabilityPolicy.Name);
Assert.Equal(3, immutabilityPolicy.ImmutabilityPeriodSinceCreationInDays);
Assert.Equal(ImmutabilityPolicyState.Locked, immutabilityPolicy.State);
immutabilityPolicy = storageMgmtClient.BlobContainers.ExtendImmutabilityPolicy(rgName, accountName, containerName, ifMatch: immutabilityPolicy.Etag, immutabilityPeriodSinceCreationInDays: 100);
Assert.NotNull(immutabilityPolicy.Id);
Assert.NotNull(immutabilityPolicy.Type);
Assert.NotNull(immutabilityPolicy.Name);
Assert.Equal(100, immutabilityPolicy.ImmutabilityPeriodSinceCreationInDays);
Assert.Equal(ImmutabilityPolicyState.Locked, immutabilityPolicy.State);
storageMgmtClient.BlobContainers.Delete(rgName, accountName, containerName);
}
finally
{
// clean up
storageMgmtClient.StorageAccounts.Delete(rgName, accountName);
resourcesClient.ResourceGroups.Delete(rgName);
}
}
}
private static Output <string> SignedBlobReadUrl(Blob blob, BlobContainer container, StorageAccount account, ResourceGroup resourceGroup)
{
return(Output.Tuple <string, string, string, string>(
blob.Name, container.Name, account.Name, resourceGroup.Name).Apply(t =>
{
(string blobName, string containerName, string accountName, string resourceGroupName) = t;
var blobSAS = ListStorageAccountServiceSAS.InvokeAsync(new ListStorageAccountServiceSASArgs
{
AccountName = accountName,
Protocols = HttpProtocol.Https,
SharedAccessStartTime = "2021-01-01",
SharedAccessExpiryTime = "2030-01-01",
Resource = SignedResource.C,
ResourceGroupName = resourceGroupName,
Permissions = Permissions.R,
CanonicalizedResource = "/blob/" + accountName + "/" + containerName,
ContentType = "application/json",
CacheControl = "max-age=5",
ContentDisposition = "inline",
ContentEncoding = "deflate",
});
return Output.Format($"https://{accountName}.blob.core.windows.net/{containerName}/{blobName}?{blobSAS.Result.ServiceSasToken}");
}));
}
public void UploadFromStream(Stream stream, string name, string contentType)
{
var blockBlob = BlobContainer.GetBlockBlobReference(name);
blockBlob.Properties.ContentType = contentType;
blockBlob.UploadFromStream(stream);
}
public CloudStorage(string storageConnectionString, string blobContainer, bool createIfNotExists = true)
{
if (string.IsNullOrWhiteSpace(blobContainer))
{
throw new Exception("O parâmetro 'blobContainer' não pode ser nulo, vazio ou em branco.");
}
if (string.IsNullOrWhiteSpace(storageConnectionString))
{
throw new Exception("O parâmetro 'storageConnectionString' não pode ser nulo, vazio ou em branco.");
}
if (blobContainer.Any(char.IsUpper))
{
throw new Exception("O parâmetro 'storageConnectionString' não pode conter caracteres em caixa alta.");
}
StorageAccount = CloudStorageAccount.Parse(storageConnectionString);
BlobClient = StorageAccount.CreateCloudBlobClient();
BlobContainer = BlobClient.GetContainerReference(blobContainer);
if (createIfNotExists)
{
BlobContainer.CreateIfNotExists();
}
}
public async Task Initialize()
{
Store = new AzureHttpMessageStore(Table, BlobContainer, UseCompression);
await Table.CreateIfNotExistsAsync(CancellationToken.None);
await BlobContainer.CreateIfNotExistsAsync(CancellationToken.None);
}
public async void UploadFromByteArrayAsync(byte[] file, string name, string contentType)
{
var blockBlob = BlobContainer.GetBlockBlobReference(name);
blockBlob.Properties.ContentType = contentType;
await blockBlob.UploadFromByteArrayAsync(file, 0, file.Length);
}
public bool DownloadFile(string blobName, string downloadFolder)
{
try
{
CloudBlockBlob blobSource = BlobContainer.GetBlockBlobReference(blobName);
if (blobSource.Exists())
{
//blob storage uses forward slashes, windows uses backward slashes; do a replace
// so localPath will be right
string localPath = Path.Combine(downloadFolder, blobSource.Name.Replace(@"/", @"\"));
//if the directory path matching the "folders" in the blob name don't exist, create them
string dirPath = Path.GetDirectoryName(localPath);
if (!Directory.Exists(localPath))
{
Directory.CreateDirectory(dirPath);
}
blobSource.DownloadToFile(localPath, FileMode.Create);
return(true);
}
return(false);
}
catch (Exception ex)
{
return(false);
}
}
protected CloudBlobContainer GetContainer(BlobContainer container)
{
var blobContainer = _blobClient.GetContainerReference(container.ToString().ToLower());
blobContainer.CreateIfNotExists();
return blobContainer;
}
public async Task SaveAsync(int categoryId, string base64Img)
{
var categoryE = await CategoryRepository.FindAsync(categoryId) ?? throw new Exception();
if (!ImageManipulator.IsImageStream(base64Img))
{
throw new Exception();
}
var buffer = Convert.FromBase64String(base64Img);
var resizedImgBuffer = ImageManipulator.ResizeImage(
buffer,
Options.CategoryThumbnail.Width,
Options.CategoryThumbnail.Height,
Options.CategoryThumbnail.ImageFormat);
var hash = Md5Hasher.GenerateBase16Hash(resizedImgBuffer);
var randomizedHash = Randomize(hash);
var fileName = string.Format("{0}.{1}", randomizedHash, Options.CategoryThumbnail.ImageFormat.ToString());
await BlobContainer.DeleteAsync(categoryE.CategoryThumbnail);
await BlobContainer.SaveBytesAsync(fileName, resizedImgBuffer);
categoryE.CategoryThumbnail = fileName;
await CategoryRepository.UpdateAsync(categoryE, autoSave : true);
}
protected async Task <CloudBlobContainer> GetContainer(BlobContainer container)
{
var blobContainer = _blobClient.GetContainerReference(container.ToString().ToLower());
await blobContainer.CreateIfNotExistsAsync();
return(blobContainer);
}
public async Task DeleteFile(BlobContainer container, string resource)
{
var blobContainer = await GetContainer(container);
CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(resource);
await blockBlob.DeleteAsync();
}
public async Task<string> UploadFile(BlobContainer container, string fileName, string relativePath, Stream stream)
{
var blobContainer = await GetContainer(container);
CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference($"{relativePath.ToLower()}/{fileName.ToLower()}");
await blockBlob.UploadFromStreamAsync(stream);
return
$"http://{_conifgruation.AccountName.ToLower()}.blob.core.windows.net/{container.ToString().ToLower()}/{relativePath.ToLower()}/{fileName.ToLower()}";
}
/// <summary>
/// Executes the Service Object method and returns any data.
/// </summary>
/// <param name="inputs">A Property[] array containing all the allowed input properties.</param>
/// <param name="required">A RequiredProperties collection containing the required properties.</param>
/// <param name="returns">A Property[] array containing all the allowed return properties.</param>
/// <param name="methodType">A MethoType indicating what type of Service Object method was called.</param>
/// <param name="serviceObject">A ServiceObject containing populated properties for use with the method call.</param>
public void Execute(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
{
crmconfig = new CRMConfig
{
CRMURL = crmurl,
CRMOrganization = crmorganization
};
#region Container
if (serviceObject.Methods[0].Name.Equals("loadcontainer"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteLoadContainer(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("listcontainers"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteListContainers(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("createcontainer"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteCreateContainer(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("setcontainerpermissions"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteSetPermissions(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("setcontainermetadata"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteSetMetadata(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("loadcontainermetadatavalue"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteLoadMetadataValue(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("listcontainermetadata"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteListMetadata(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("deletecontainer"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteDeleteContainer(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("listcontainerfolders"))
{
BlobContainer container = new BlobContainer(serviceBroker);
container.ExecuteListContainerFolders(inputs, required, returns, methodType, serviceObject);
}
#endregion Container
#region Blob
if (serviceObject.Methods[0].Name.Equals("loadblob"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteLoadBlob(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("setblobmetadata"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteSetBlobMetadata(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("loadblobmetadatavalue"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteLoadBlobMetadataValue(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("listblobmetadata"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteListBlobMetadata(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("deleteblob"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteDeleteBlob(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("uploadblob"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteUploadBlob(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("uploadblobfrombase64"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteUploadBlobFromBase64(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("uploadblobfromfilesystem"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteUploadBlobFromFilePath(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("uploadblobfromurl"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteUploadBlobFromUrl(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("listblobs"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteListBlobs(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("downloadblob"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteDownloadBlob(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("downloadblobtobase64"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteDownloadBlobAsBase64(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("downloadblobtofilesystem"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteDownloadBlobToFileSystem(inputs, required, returns, methodType, serviceObject);
}
if (serviceObject.Methods[0].Name.Equals("setblobproperties"))
{
BlobBlob blob = new BlobBlob(serviceBroker);
blob.ExecuteSetBlobProperties(inputs, required, returns, methodType, serviceObject);
}
#endregion Blob
}
public BlobContainerViewModel(BlobContainer container)
{
this.Container = container;
this.Container.MadeProgress += OnMadeProgress;
}
void OnMadeProgress(object sender, BlobContainer container)
{
RaisePropertyChanged("Status");
RaisePropertyChanged("PercentageComplete");
RaisePropertyChanged("Errors");
}