public static void TestResizeUserFile()
{
var settings = Common.AppSettings.ReadSettings();
var currentDirectory = Directory.GetCurrentDirectory();
using (var fileStream = File.OpenRead(currentDirectory + "\\TestData\\mister.jpg"))
{
var blobService = new BlobService(settings, null);
var blobData = new BlobDataDto()
{
FileName = "mister.jpg", Stream = fileStream
};
var stream1 = blobService.ResizeToAvatar(fileStream, 100, 100);
string path = @"C:\Temp\z1.jpg";
if (File.Exists(path))
{
File.Delete(path);
}
using (var fileStream1 = File.OpenWrite(path))
{
stream1.Position = 0;
stream1.CopyTo(fileStream1);
}
}
}
public async Task <IActionResult> Index()
{
var blobService = new BlobService();
List <string> imageList = await blobService.GetBlobList(_connectionString);
return(View(imageList));
}
public void Initialize()
{
fixture = new Fixture();
processRepository = new Mock <IProcessRepository>();
blobRepository = new Mock <IBlobRepository>();
sut = new BlobService(null, processRepository.Object, blobRepository.Object);
}
public void AddUserToBlob()
{
using (TransactionScope ts = new TransactionScope())
{
BlobShareDataStoreEntities context = BlobShareDataStoreEntities.CreateInstance();
Blob blob = BlobServicesTests.CreateBlobForTest("Test Resource", context);
User user = CreateUserForTest("testuser1", context);
PermissionService service = new PermissionService(context);
Permission permission = service.GrantPermissionToUserBlob(Privilege.Read, user, blob, DateTime.UtcNow.AddDays(1));
Assert.IsNotNull(permission);
Assert.AreEqual(user, permission.Users.First());
Assert.AreEqual(blob, permission.Blob);
Assert.AreEqual((int)Privilege.Read, permission.Privilege);
IEnumerable <Blob> resources = service.GetBlobsByUser(user);
Assert.IsNotNull(resources);
Assert.AreEqual(1, resources.Count());
Assert.AreEqual(blob.BlobId, resources.First().BlobId);
Assert.IsTrue(service.CheckPermissionToBlob(user.NameIdentifier, user.IdentityProvider, blob.BlobId));
BlobService blobService = new BlobService(context, CloudStorageAccount.DevelopmentStorageAccount, TestContainerName);
CloudBlob cloudBlob = blobService.GetBlob(blob);
cloudBlob.Delete();
}
}
public static async Task Run(
// At 20 seconds past the minute every 3 minutes, between 7:00 PM and 7:59 AM every day except
// from 4 AM to 5 AM when site maintenance seems like it might be happening--matching SyncGames.
[TimerTrigger("20 */3 0-3,5-7,19-23 * * *")] TimerInfo timer,
ILogger log)
{
var queueService = new QueueService(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
string playerID = await queueService.GetNextPlayerFromBuildGamesBlobQueue();
log.LogInformation($"Got next player from BuildGamesBlob queue: {playerID ?? "N/A"}.");
if (playerID == null)
{
return;
}
var tableService = new TableService(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
var games = (await tableService.GetGameRows(playerID))
.Select(r => new GameBlobObject(r))
.OrderBy(r => r.Date)
.ToArray();
log.LogInformation($"Queried games table for {playerID}: {games.Length} games found.");
var blobService = new BlobService(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
await blobService.UploadGamesBlobContent(playerID, JsonConvert.SerializeObject(games));
log.LogInformation($"{playerID}'s games blob updated.");
await queueService.RemovePlayerFromBuildGamesBlobQueue(playerID);
log.LogInformation($"Removed {playerID} from BuildGamesBlob queue.");
}
public async Task <IHttpActionResult> GetVideoContent(Guid id)
{
var VideoFile = await db.Videos.FindAsync(id);
if (VideoFile == null)
{
return(NotFound());
}
var blobService = new BlobService();
var result = await blobService.DownloadBlob(VideoFile.Id.ToString(), BlobHelper.Repository.Video);
// Reset the stream position; otherwise, download will not work
result.BlobStream.Position = 0;
var filePath = Path.GetTempPath() + id;
using (var fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write))
{
result.BlobStream.WriteTo(fs);
result.BlobStream.Close();
fs.Close();
}
return(new FileResult(filePath, "application/octet-stream"));
}
public async Task Update_Success()
{
// Arrange
var loggerController = Loggers.CategoryController();
var blobService = BlobService.BlobServiceUpload();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var oldCategory = NewDatas.NewCategory();
await dbContext.AddAsync(oldCategory);
await dbContext.SaveChangesAsync();
var newCategoryRequest = NewDatas.NewCategoryRequest();
var categoryRepository = new CategoryRepository(mapper, blobService, dbContext);
var catgoriesController = new CategoriesController(loggerController, categoryRepository);
// Act
var result = await catgoriesController.Update(oldCategory.CategoryId, newCategoryRequest);
// Assert
var createdCategoryResult = Assert.IsType <OkObjectResult>(result.Result);
var resultValue = Assert.IsType <CategoryRespone>(createdCategoryResult.Value);
Assert.Equal(oldCategory.Name, resultValue.Name);
Assert.Equal(oldCategory.Description, resultValue.Description);
Assert.Equal(oldCategory.Image, resultValue.Image);
Assert.Equal(oldCategory.Name, newCategoryRequest.Name);
Assert.Equal(oldCategory.Description, newCategoryRequest.Description);
Assert.Equal(oldCategory.Image, newCategoryRequest.Image);
}
/* -- DATABASE / SAVE FUNCTIONS -- */
private async Task <bool> TryStoreFileAsync()
{
try
{
if (_ticket.HasAttachment)
{
await BlobService.StoreFileAsync(_file, _ticket.Id);
_ticket.AttachmentExtension = _file.FileType;
}
return(true);
}
catch (FileLoadException flEx)
{
Debug.WriteLine($"File could not be loaded. {flEx}");
tbAttachment.Text = "File access error. Try again or try another file.";
errorDialog.Content = flEx.Message;
await errorDialog.ShowAsync();
}
catch (UnauthorizedAccessException uaEx)
{
Debug.WriteLine($"File could not be loaded. {uaEx}");
tbAttachment.Text = "File access error. Try again or try another file.";
errorDialog.Content = uaEx.Message;
await errorDialog.ShowAsync();
}
return(false);
}
public AzureStorage()
{
//String storageConnectionString = "DefaultEndpointsProtocol=https;AccountName=oom;AccountKey=sIRqaNUlztHLFaaE/BKasMU/zg4M3V4+a8pfKI/oiUcGtv51VDoMWqt3E1UK+6Ion5jmohFM3+uTl7pMcrdQjw==";
StorageServiceClient cl = new StorageServiceClient("oom", "sIRqaNUlztHLFaaE/BKasMU/zg4M3V4+a8pfKI/oiUcGtv51VDoMWqt3E1UK+6Ion5jmohFM3+uTl7pMcrdQjw==");
bs = new BlobService(cl);
}
private async Task TryDeleteFileAsync()
{
try
{
await BlobService.DeleteFileIfExists(_ticket.AttachmentFileName);
_ticket.AttachmentExtension = null;
}
catch (FileLoadException flEx)
{
Debug.WriteLine($"File could not be loaded. {flEx}");
tbAttachment.Text = "File access error. Try again or try another file.";
errorDialog.Content = flEx.Message;
await errorDialog.ShowAsync();
}
catch (UnauthorizedAccessException uaEx)
{
Debug.WriteLine($"File could not be loaded. {uaEx}");
tbAttachment.Text = "File access error. Try again or try another file.";
errorDialog.Content = uaEx.Message;
await errorDialog.ShowAsync();
}
}
public void Dispose()
{
if (_emulator != null)
{
BlobService.DeleteBlobsAsync().Wait();
}
}
public DestinationController(DestinationDAL destinationDAL, BlobService blobService, Microsoft.Extensions.Configuration.IConfiguration configuration)
{
this.destinationDAL = destinationDAL;
this.blobService = blobService;
this.logger = new LoggerConfiguration()
.WriteTo.AzureBlobStorage(configuration["Data:StorageAccount"], Serilog.Events.LogEventLevel.Information, $"logs", "{yyyy}/{MM}/{dd}/log.txt").CreateLogger();
}
public AdminController()
{
categoryService = new CategoryService();
goodService = new GoodService();
blobService = new BlobService();
queueService = new QueueService();
}
public async Task <IHttpActionResult> GetPhotoContent(Guid id)
{
var photo = await db.Photos.FindAsync(id);
if (photo == null)
{
return(NotFound());
}
var blobService = new BlobService();
var result = await blobService.DownloadBlob(photo.Id.ToString(), BlobHelper.Repository.Photos);
// Reset the stream position; otherwise, download will not work
result.BlobStream.Position = 0;
var filePath = Path.GetTempPath() + id;
using (var fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write))
{
result.BlobStream.WriteTo(fs);
result.BlobStream.Close();
fs.Close();
}
return(new FileResult(filePath, "image/" + photo.Extension.Replace(".", "").Replace("jpg", "jpeg")));
}
void Start()
{
client = StorageServiceClient.Create(storageAccount, accessKey);
blobService = client.GetBlobService();
GetBlobList();
currentFile = "";
}
public void UplodedFileShouldUploadAFileAndReturnString()
{
//Arrange
var fileMock = new Mock <IFormFile>();
//Setup mock file using a memory stream
var content = "Hello World from a Fake File";
var fileName = "test.pdf";
var ms = new MemoryStream();
var writer = new StreamWriter(ms);
writer.Write(content);
writer.Flush();
ms.Position = 0;
fileMock.Setup(_ => _.OpenReadStream()).Returns(ms);
fileMock.Setup(_ => _.FileName).Returns(fileName);
fileMock.Setup(_ => _.Length).Returns(ms.Length);
IConfiguration configuration = TestsPrerequisites.GetConfiguration();
var sut = new BlobService(configuration);
var file = fileMock.Object;
//Act
var result = sut.BlobUpload(file, "test.file");
//Assert
Assert.IsType <string>(result);
Assert.Equal("test.file", result);
}
public void RemoveSet()
{
using (TransactionScope ts = new TransactionScope())
{
BlobShareDataStoreEntities context = BlobShareDataStoreEntities.CreateInstance();
BlobSet set = CreateBlobSetForTest("Test List", context);
Blob blob = BlobServicesTests.CreateBlobForTest("Test Resource", context);
BlobSetService service = new BlobSetService(context);
service.AddBlobToSet(set.BlobSetId, blob.BlobId);
BlobSet newList = service.GetBlobSetById(set.BlobSetId);
Assert.IsNotNull(newList);
Assert.AreEqual(1, newList.Blobs.Count);
service.DeleteBlobSet(set.BlobSetId);
BlobSet deletedList = service.GetBlobSetById(set.BlobSetId);
Assert.IsNull(deletedList);
BlobService bservices = new BlobService(context, CloudStorageAccount.DevelopmentStorageAccount, TestContainerName);
Blob newResource = bservices.GetBlobById(blob.BlobId);
Assert.IsNotNull(newResource);
Assert.AreEqual(0, newResource.BlobSets.Count);
}
}
public static async Task Run(
// At 9:00 AM every day.
[TimerTrigger("0 0 9 * * *")] TimerInfo timer,
ILogger log)
{
var blobService = new BlobService(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
string playersBlobContent = await blobService.DownloadPlayersBlobContent();
var blobPlayers = JsonConvert.DeserializeObject <IReadOnlyList <PlayerBlobObject> >(playersBlobContent ?? "[]");
log.LogInformation($"Downloaded players blob: {blobPlayers.Count} players found.");
var tableService = new TableService(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
var tablePlayers = (await tableService.GetPlayerRows())
.Where(r => r.HasSyncedGames)
.Select(r => new PlayerBlobObject(r))
.OrderBy(p => p)
.ToArray();
log.LogInformation($"Queried players table: {tablePlayers.Length} players with synced games found.");
if (!tablePlayers.SequenceEqual(blobPlayers))
{
await blobService.UploadPlayersBlobContent(JsonConvert.SerializeObject(tablePlayers));
log.LogInformation("Players blob updated.");
}
else
{
log.LogInformation("Players blob already up to date.");
}
}
public async Task <ActionResult> UploadImages()
{
var files = Request.Files;
var blobService = new BlobService();
for (int i = 0; i < files.Count; i++)
{
var imageFile = files[i];
string imageUrl = await blobService.UploadImage("gallerycontainer",
imageFile.FileName,
imageFile.InputStream,
imageFile.ContentType);
ImageViewModel image = new ImageViewModel();
image.Url = imageUrl;
//--- Add to StorageTable ---
TableService tableService = new TableService();
tableService.AddImage(image.Url);
_images = tableService.GetAllImages().Select(url => new ImageViewModel()
{
Url = url
});
//---------------------------
}
return(View("Index", _images));
}
private async Task LoadBlobListViewAsync(ContainerNode containerNode, string directory = null)
{
if (containerNode == null)
{
throw new NullReferenceException("No container selected.");
}
var accountNode = containerNode.Parent as AccountNode;
_breadcrumb.Clear();
_breadcrumb.Add(accountNode);
_breadcrumb.Add(containerNode, async(node) => await LoadBlobListViewAsync(node));
if (!string.IsNullOrEmpty(directory))
{
_breadcrumb.AddPath(directory, async(folder) => await LoadBlobListViewAsync(containerNode, folder.FullPath));
}
await DoActionAsync(tslBlobStatus, $"Listing blobs in {containerNode.Name}...", async() =>
{
var service = new BlobService(accountNode.Name, accountNode.Account.Key);
var results = await service.ListBlobsAndDirectoriesAsync(containerNode.Name, directory);
tslBlobStatus.Text = $"{results.Blobs.Count():n0} blobs, {results.Directories.Count():n0} folders";
lvBlobs.BeginUpdate();
lvBlobs.Items.Clear();
lvBlobs.Items.AddRange(results.Directories.Select(folder => new FolderItem(folder)).ToArray());
lvBlobs.Items.AddRange(results.Blobs.Select(blob => new BlobItem(blob, imlSmallIcons)).ToArray());
lvBlobs.EndUpdate();
}, false);
}
public void TestMethod1()
{
//Preparar para o teste
var blobService = new BlobService();
string url = blobService.UploadImage();
}
public ActionResult Add(Contact model)
{
var contactService = new ContactService();
// Handling file upload; save the uploaded contact picture into Azure blob storage.
string pictureFilename = string.Empty;
if (Request.Files.Count > 0)
{
var file = Request.Files[0];
if (file != null && file.ContentLength > 0)
{
var fileName = Path.GetFileName(file.FileName);
var path = Path.Combine(Server.MapPath("~/Images/"), fileName);
file.SaveAs(path);
var blobService = new BlobService();
pictureFilename = blobService.UploadPictureToBlob(Server.MapPath("~/Images/"), fileName);
}
}
var id = contactService.AddContact(new Contact()
{
Name = model.Name,
Address = model.Address,
Email = model.Email,
Phone = model.Phone,
PictureName = pictureFilename,
SIN_Number = model.SIN_Number
});
return(RedirectToAction("index"));
}
public async Task <ScrollableList <Blob> > Upload()
{
// check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
// write uploaded files to local disk cache
var provider = await Request.Content.ReadAsMultipartAsync(new BlobMultipartFormDataRemoteStreamProvider());
// iterate over the uploaded files and store them as blobs in the database
List <Blob> blobs = new List <Blob>();
foreach (var data in provider.FileData)
{
var blob = provider.GetBlob(data);
if (blob != null)
{
try {
blob = BlobService.Insert(blob, System.IO.File.OpenRead(data.Location));
blobs.Add(blob);
} catch {
ThrowResponseException(HttpStatusCode.InternalServerError, "Failed to upload blobs");
}
}
}
return(new ScrollableList <Blob>(blobs, null, null, blobs.Count(), Request.RequestUri));
}
public override void Given()
{
expectedStage2Response = new List <ResultCsvRecordResponse>
{
new ResultCsvRecordResponse {
RowNum = 1, Uln = 1111111111, CoreCode = "1234567", CoreAssessmentSeries = "Summer 2021", CoreGrade = "A", ValidationErrors = new List <BulkProcessValidationError>
{
new BulkProcessValidationError {
RowNum = "1", Uln = "1111111111", ErrorMessage = "Core component code must have 8 digits only"
}
}
},
new ResultCsvRecordResponse {
RowNum = 2, Uln = 1111111112, CoreCode = "", CoreAssessmentSeries = "Summer 2021", CoreGrade = "A", ValidationErrors = new List <BulkProcessValidationError>
{
new BulkProcessValidationError {
RowNum = "2", Uln = "1111111112", ErrorMessage = "Core component code required when result is included"
}
}
}
};
var csvResponse = new CsvResponseModel <ResultCsvRecordResponse> {
Rows = expectedStage2Response
};
CsvService.ReadAndParseFileAsync(Arg.Any <ResultCsvRecordRequest>()).Returns(csvResponse);
ResultService.ValidateResultsAsync(AoUkprn, Arg.Any <IEnumerable <ResultCsvRecordResponse> >()).Returns(new List <ResultRecordResponse>());
BlobService.DownloadFileAsync(Arg.Any <BlobStorageData>()).Returns(new MemoryStream(Encoding.ASCII.GetBytes("Test File")));
var expectedWriteFileBytes = new byte[5];
CsvService.WriteFileAsync(Arg.Any <List <BulkProcessValidationError> >()).Returns(expectedWriteFileBytes);
}
public async Task Delete_Success()
{
// Arrange
var loggerController = Loggers.CategoryController();
var blobService = BlobService.BlobServiceUpload();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
await dbContext.AddRangeAsync(category);
await dbContext.SaveChangesAsync();
var categoryRepository = new CategoryRepository(mapper, blobService, dbContext);
var catgoriesController = new CategoriesController(loggerController, categoryRepository);
// Act
var result = await catgoriesController.Delete(category.CategoryId);
// Assert
var createdCategoryResult = Assert.IsType <OkObjectResult>(result.Result);
var resultValue = Assert.IsType <CategoryRespone>(createdCategoryResult.Value);
Assert.Equal(category.Name, resultValue.Name);
Assert.Equal(category.Description, resultValue.Description);
Assert.Equal(category.Image, resultValue.Image);
await Assert.ThrowsAsync <NotFoundException>(async() =>
{
await catgoriesController.GetById(resultValue.CategoryId);
});
}
public override ICollection <string> GetAnalysisAsync(string imageName)
{
BlobService blobService = new BlobService();
string imageUrl = blobService.GetPictureUrlByName(imageName);
this.visionClient.Endpoint = base.endpoint;
if (!Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
{
Console.WriteLine(
"\nInvalid remoteImageUrl:\n{0} \n", imageUrl);
}
var task = this.visionClient.AnalyzeImageAsync(imageUrl, this.FeatureTypes());
Task.WaitAll(task);
ICollection <string> tags = new HashSet <string>();
foreach (var item in task.Result.Tags)
{
tags.Add(item.Name);
}
return(tags);
}
public async Task createStorageAccountAndGetBlobContainerCollection()
{
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
string rgName = "myRgName";
AzureLocation location = AzureLocation.WestUS2;
ArmOperation <ResourceGroup> operation = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, rgName, new ResourceGroupData(location));
ResourceGroup resourceGroup = operation.Value;
this.resourceGroup = resourceGroup;
StorageSku sku = new StorageSku(StorageSkuName.StandardGRS);
StorageKind kind = StorageKind.Storage;
string locationStr = "westus2";
StorageAccountCreateParameters parameters = new StorageAccountCreateParameters(sku, kind, locationStr);
StorageAccountCollection accountCollection = resourceGroup.GetStorageAccounts();
string accountName = "myAccount";
ArmOperation <StorageAccount> accountCreateOperation = await accountCollection.CreateOrUpdateAsync(WaitUntil.Started, accountName, parameters);
storageAccount = await accountCreateOperation.WaitForCompletionAsync();
#region Snippet:Managing_BlobContainers_GetBlobService
BlobService blobService = storageAccount.GetBlobService();
#endregion
this.blobService = blobService;
}
public async Task GetAll_Success()
{
// Arrange
var loggerController = Loggers.CategoryController();
var blobService = BlobService.BlobServiceUpload();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category1 = NewDatas.NewCategory();
var category2 = NewDatas.NewCategory();
var category3 = NewDatas.NewCategory();
await dbContext.AddRangeAsync(category1, category2, category3);
await dbContext.SaveChangesAsync();
var categoryRepository = new CategoryRepository(mapper, blobService, dbContext);
var catgoriesController = new CategoriesController(loggerController, categoryRepository);
// Act
var result = await catgoriesController.GetAll();
// Assert
var getCategoriesResultType = Assert.IsType <ActionResult <IEnumerable <CategoryRespone> > >(result);
var getCategoriesResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotEmpty(getCategoriesResult.Value as IEnumerable <CategoryRespone>);
}
private void ValidateBlobService(BlobService blobService)
{
Assert.NotNull(blobService);
Assert.NotNull(blobService.BlobSvcContainerGcInterval);
Assert.NotNull(blobService.BlobSvcShallowGcInterval);
Assert.NotNull(blobService.BlobSvcStreamMapMinContainerOccupancyPercent);
Assert.NotNull(blobService.FrontEndCallbackThreadsCount);
Assert.NotNull(blobService.FrontEndCpuBasedKeepAliveThrottlingCpuMonitorIntervalInSeconds);
Assert.NotNull(blobService.FrontEndCpuBasedKeepAliveThrottlingEnabled);
Assert.NotNull(blobService.FrontEndCpuBasedKeepAliveThrottlingPercentCpuThreshold);
Assert.NotNull(blobService.FrontEndCpuBasedKeepAliveThrottlingPercentRequestsToThrottle);
Assert.NotNull(blobService.FrontEndHttpListenPort);
Assert.NotNull(blobService.FrontEndHttpsListenPort);
Assert.NotNull(blobService.FrontEndMaxMillisecondsBetweenMemorySamples);
Assert.NotNull(blobService.FrontEndMemoryThrottleThresholdSettings);
Assert.NotNull(blobService.FrontEndMemoryThrottlingEnabled);
Assert.NotNull(blobService.FrontEndMinThreadPoolThreads);
Assert.NotNull(blobService.FrontEndThreadPoolBasedKeepAliveIOCompletionThreshold);
Assert.NotNull(blobService.FrontEndThreadPoolBasedKeepAliveMonitorIntervalInSeconds);
Assert.NotNull(blobService.FrontEndThreadPoolBasedKeepAlivePercentage);
Assert.NotNull(blobService.FrontEndThreadPoolBasedKeepAliveWorkerThreadThreshold);
Assert.NotNull(blobService.FrontEndUseSlaTimeInAvailability);
Assert.NotNull(blobService.Id);
Assert.NotNull(blobService.Location);
Assert.NotNull(blobService.Name);
Assert.NotNull(blobService.Type);
Assert.NotNull(blobService.Version);
}
public override void Given()
{
expectedStage2Response = new List <AssessmentCsvRecordResponse>
{
new AssessmentCsvRecordResponse {
RowNum = 1, ValidationErrors = new List <BulkProcessValidationError>
{
new BulkProcessValidationError {
RowNum = "1", ErrorMessage = "TestErrorMessage1"
}
}
},
new AssessmentCsvRecordResponse {
RowNum = 2, ValidationErrors = new List <BulkProcessValidationError>
{
new BulkProcessValidationError {
RowNum = "2", ErrorMessage = "TestErrorMessage2"
}
}
}
};
var csvResponse = new CsvResponseModel <AssessmentCsvRecordResponse> {
Rows = expectedStage2Response
};
CsvService.ReadAndParseFileAsync(Arg.Any <AssessmentCsvRecordRequest>()).Returns(csvResponse);
BlobService.DownloadFileAsync(Arg.Any <BlobStorageData>()).Returns(new MemoryStream(Encoding.ASCII.GetBytes("Test File")));
var expectedWriteFileBytes = new byte[5];
CsvService.WriteFileAsync(Arg.Any <List <BulkProcessValidationError> >()).Returns(expectedWriteFileBytes);
}
//public static BlobService CreateBlobServiceClient()
//{
// var blobService = new BlobService(ConfigurationManager.AppSettings["AzureStorageConnection"]);
// return blobService;
//}
public static void UploadFilesByFolder(BlobService blobService, string container, string folderToUpload, string virtualFolder = "")
{
var allFiles = Directory.GetFiles(folderToUpload);
Dictionary<string, string> dic = new Dictionary<string, string>();
foreach (var f in allFiles)
{
dic.Add(virtualFolder + Path.GetFileName(f), f);
}
blobService.UploadFiles(container, dic);
}
public ActionResult UploadFile()
{
ViewBag.Title = "Upload File to Azure Storage";
//string containerName = "babyimages".ToLower(); //All letters in a container name must be lowercase.
var blobService = new BlobService(ConfigurationManager.AppSettings["AzureStorageConnection"]); //AzureStorageBLL.CreateBlobServiceClient();
//blobService.CreatePublicContainer(containerName);
blobService.UploadFileToBlob(BabybookConfig.ContainerName, HostingEnvironment.MapPath("~/Images/ps1.jpg"), "2014/");
var result = blobService.ListBlobs(BabybookConfig.ContainerName, false).Split(new[] { '\r', '\n' },StringSplitOptions.RemoveEmptyEntries);
ViewBag.BlobList = result;
return View();
}
public HomeController()
{
coffeeService = new CoffeeService();
blobService = new BlobService();
}
