public virtual Uri UploadFile(
string storageName,
Uri blobEndpointUri,
string storageKey,
string filePath,
BlobRequestOptions blobRequestOptions)
{
StorageCredentials credentials = new StorageCredentials(storageName, storageKey);
CloudBlobClient client = new CloudBlobClient(blobEndpointUri, credentials);
string blobName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}",
DateTime.UtcNow.ToString("yyyyMMdd_HHmmss", CultureInfo.InvariantCulture),
Path.GetFileName(filePath));
CloudBlobContainer container = client.GetContainerReference(ContainerName);
container.CreateIfNotExists();
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
BlobRequestOptions uploadRequestOption = blobRequestOptions ?? new BlobRequestOptions();
if (!uploadRequestOption.ServerTimeout.HasValue)
{
uploadRequestOption.ServerTimeout = TimeSpan.FromMinutes(300);
}
using (FileStream readStream = File.OpenRead(filePath))
{
blob.UploadFromStream(readStream, AccessCondition.GenerateEmptyCondition(), uploadRequestOption);
}
return new Uri(string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}{3}", client.BaseUri, ContainerName, client.DefaultDelimiter, blobName));
}
public static CloudBlobContainer GetCloudBlobContainer(string storageAccount, string storageKey, string containerName)
{
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(new StorageCredentials(storageAccount, storageKey), true);
CloudBlobClient blobClient = cloudStorageAccount.CreateCloudBlobClient();
return(blobClient?.GetContainerReference(containerName));
}
/// <summary>
/// Uploads a file to azure store.
/// </summary>
/// <param name="storageName">Store which file will be uploaded to</param>
/// <param name="storageKey">Store access key</param>
/// <param name="filePath">Path to file which will be uploaded</param>
/// <param name="blobRequestOptions">The request options for blob uploading.</param>
/// <returns>Uri which holds locates the uploaded file</returns>
/// <remarks>The uploaded file name will be guid</remarks>
public static Uri UploadFile(string storageName, string storageKey, string filePath, BlobRequestOptions blobRequestOptions)
{
string baseAddress = General.BlobEndpointUri(storageName);
var credentials = new StorageCredentialsAccountAndKey(storageName, storageKey);
var client = new CloudBlobClient(baseAddress, credentials);
string blobName = Guid.NewGuid().ToString();
CloudBlobContainer container = client.GetContainerReference(ContainerName);
container.CreateIfNotExist();
CloudBlob blob = container.GetBlobReference(blobName);
using (FileStream readStream = File.OpenRead(filePath))
{
blob.UploadFromStream(readStream, blobRequestOptions);
}
return new Uri(
string.Format(
CultureInfo.InvariantCulture,
"{0}{1}{2}{3}",
client.BaseUri,
ContainerName,
client.DefaultDelimiter,
blobName));
}
/// <summary>
/// This is the main entry point for your service instance.
/// </summary>
/// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service instance.</param>
//protected override async Task RunAsync(CancellationToken cancellationToken)
//{
// // TODO: Replace the following sample code with your own logic
// // or remove this RunAsync override if it's not needed in your service.
// long iterations = 0;
// while (true)
// {
// cancellationToken.ThrowIfCancellationRequested();
// ServiceEventSource.Current.ServiceMessage(this.Context, "Working-{0}", ++iterations);
// await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
// }
//}
public async Task <bool> Validate(IlrContext ilrContext, IValidationService validationService)
{
using (var logger = ESFA.DC.Logging.LoggerManager.CreateDefaultLogger(ilrContext.CorrelationId.ToString()))
{
var startDateTime = DateTime.Now;
logger.LogInfo($"Validation started for:{ilrContext.Filename} at :{startDateTime}");
Message message = new Message();
//try
//{
var stopwatch = new Stopwatch();
stopwatch.Start();
string xml;
CloudStorageAccount cloudStorageAccount =
CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
var cloudStorageAccountElapsed = stopwatch.ElapsedMilliseconds;
CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
var cloudBlobClientElapsed = stopwatch.ElapsedMilliseconds;
CloudBlobContainer cloudBlobContainer =
cloudBlobClient.GetContainerReference(ilrContext.ContainerReference);
var cloudBlobContainerElapsed = stopwatch.ElapsedMilliseconds;
CloudBlockBlob cloudBlockBlob = cloudBlobContainer.GetBlockBlobReference(ilrContext.Filename);
var cloudBlockBlobElapsed = stopwatch.ElapsedMilliseconds;
xml = cloudBlockBlob.DownloadText();
var blob = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();
using (var reader = XmlReader.Create(new StringReader(xml)))
{
var serializer = new XmlSerializer(typeof(Message));
message = serializer.Deserialize(reader) as Message;
}
var deserialize = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();
IEnumerable <LearnerValidationError> results;
var totalLearners = message.Learner.Count();
if (ilrContext.IsShredAndProcess)
{
// create actors here.
results = DivideAndConquer(ilrContext.CorrelationId, message, logger);
}
else
{
results = await validationService.Validate(message);
}
var validate = stopwatch.ElapsedMilliseconds;
var endTime = DateTime.Now;
var processTimes = new List <string>()
{
string.Format("Start Time : {0}", startDateTime),
string.Format("Learners : {0}", totalLearners),
string.Format("Errors : {0}", results.Count()),
string.Format("Blob Client : {0}", cloudBlobClientElapsed),
string.Format("Blob Container : {0}", cloudBlobContainerElapsed),
string.Format("Blob Block Blob : {0}", cloudBlockBlobElapsed),
string.Format("Blob Download Text : {0}", blob),
string.Format("Deserialize ms : {0}", deserialize),
string.Format("Validation ms : {0}", validate),
string.Format("End Time : {0}", endTime),
string.Format("Total Time : {0}", (endTime - startDateTime).TotalMilliseconds),
};
stopwatch.Restart();
//store the results in reliable dictionary
await SaveResultsInDataService(ilrContext.CorrelationId, processTimes, xml);
logger.LogInfo("Stateless Validation Results:{@processTimes}", processTimes.ToArray(), "",
ilrContext.Filename);
var saveResultsTime = stopwatch.ElapsedMilliseconds;
logger.LogInfo($"saved Results to Db in: {saveResultsTime}");
stopwatch.Restart();
//send message topic to be picked up by next service
dynamic data = new { To = _fundingCalcSqlFilterValue };
var pubMessage =
new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data))))
{
ContentType = "application/json",
Label = data.To,
CorrelationId = ilrContext.CorrelationId.ToString(),
MessageId = Guid.NewGuid().ToString(),
Properties =
{
{ "To", data.To },
{ "fileName", ilrContext.Filename }
},
TimeToLive = TimeSpan.FromMinutes(2)
};
await _topicHelper.SendMessage(pubMessage);
var pushedToTopicTime = stopwatch.ElapsedMilliseconds;
logger.LogInfo($"pushed message into Topic in: {pushedToTopicTime} , {data}");
return(true);
}
}
/// <summary>
/// Delete a job and all cloud storage associated with the job.
/// </summary>
/// <param name="jobID">ID of the job.</param>
/// <param name="ct">Cancellation token.</param>
public async Task DeleteJobAsync(string jobID, CancellationToken ct)
{
Guid parsedID = Guid.Parse(jobID);
// Delete cloud storage associated with the job.
await storageClient.GetContainerReference(StorageConstants.GetJobOutputContainer(parsedID)).DeleteIfExistsAsync(ct);
if (ct.IsCancellationRequested)
{
return;
}
await storageClient.GetContainerReference(StorageConstants.GetJobContainer(parsedID)).DeleteIfExistsAsync(ct);
if (ct.IsCancellationRequested)
{
return;
}
await storageClient.GetContainerReference(jobID).DeleteIfExistsAsync(ct);
if (ct.IsCancellationRequested)
{
return;
}
// Delete the job.
await batchClient.JobOperations.DeleteJobAsync(jobID, cancellationToken : ct);
}
//[HttpPost("registerPerson")]
public async Task <IActionResult> AddPerson(Books book)
{
decimal d = 1.23M;
var bookdata = new Books()
{
BookName = "John",
Price = d
};
await _bookRepo.InsertOneAsync(bookdata);
//code for uploading blob data to azure
BlobStorageService objBlobService = new BlobStorageService(_configuration);
byte[] fileData = new byte[book.File.Length];
string mimeType1 = book.File.ContentType;
book.Author = objBlobService.UploadFileToBlob("ankush.pdf", book.File);
string accessKey =
"DefaultEndpointsProtocol=https;AccountName=referraldocuments;AccountKey=ID4sHh6dof/G8x/Qq83WkvhG4H1hYOi9pI1vxpYasXNtXVERREEv2jcZBWOp0dXmv85wEB9lb6gS2hJrCwylqA==;EndpointSuffix=core.windows.net";
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(accessKey);
CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
CloudBlobContainer cloudBlobContainer = cloudBlobClient.GetContainerReference("uploads");
var blockBlob = cloudBlobContainer.GetBlobReference("ankush.pdf");
string fileName = "ankush.pdf";
MemoryStream memStream = new MemoryStream();
await blockBlob.DownloadToStreamAsync(memStream);
HttpResponse response = HttpContext.Response;
//response.ContentType = blockBlob.Properties.ContentType;
response.ContentType = blockBlob.Properties.ContentType;
response.Headers.Add("Content-Disposition", "Attachment; filename=" + fileName);
response.Headers.Add("Content-Length", blockBlob.Properties.Length.ToString());
return(File(memStream.ToArray(), blockBlob.Properties.ContentType, "ankush.pdf"));
//CloudBlockBlob blob = cloudBlobContainer.GetBlockBlobReference("ankush.pdf");
//var exists = blob.ExistsAsync(); // to verify if file exist
//await blob.FetchAttributesAsync();
//byte[] dataBytes1;
//var outputStream = new MemoryStream();
//using (StreamReader blobfilestream = new StreamReader(await blob.OpenReadAsync()))
//{
// dataBytes1 = blobfilestream.CurrentEncoding.GetBytes(blobfilestream.ReadToEnd());
// await blob.DownloadToStreamAsync(outputStream);
//}
//Byte[] value = BitConverter.GetBytes(dataBytes1.Length - 1);
//string mimeType = "application/pdf";
//Response.Headers.Add("Content-Disposition", "inline; filename=" + "filename.pdf");
//return File(value, mimeType,"abc.pdf");
//code for triggering mail using azure grid
//var apiKey = _configuration.GetSection("SENDGRID_API_KEY").Value;
//var client = new SendGridClient(apiKey);
//var from = new EmailAddress("*****@*****.**", "Example User 1");
//List<EmailAddress> tos = new List<EmailAddress>
//{
// new EmailAddress("*****@*****.**", "Example User 2")
//};
//var subject = "Hello world email from Sendgrid ";
//var htmlContent = "<strong>Hello world with HTML content</strong>";
//var displayRecipients = false; // set this to true if you want recipients to see each others mail id
//var msg = MailHelper.CreateSingleEmailToMultipleRecipients(from, tos, subject, "", htmlContent, false);
//var response = await client.SendEmailAsync(msg);
//decimal d = 1.23M;
//var bookdata = new Books()
//{
// BookName = "John",
// Price = d
//};
//await _bookRepo.InsertOneAsync(bookdata);
}
public async Task <UpsertOutcome> UpsertAsync(ResourceWrapper resource, WeakETag weakETag, bool allowCreate, bool keepHistory, CancellationToken cancellationToken)
{
await _model.EnsureInitialized();
int etag = 0;
if (weakETag != null && !int.TryParse(weakETag.VersionId, out etag))
{
throw new ResourceConflictException(weakETag);
}
var resourceMetadata = new ResourceMetadata(
resource.CompartmentIndices,
resource.SearchIndices?.ToLookup(e => _searchParameterTypeMap.GetSearchValueType(e)),
resource.LastModifiedClaims);
DynamicsCrmFhirDataStore crmFhirDataStoreObj = new DynamicsCrmFhirDataStore();
try
{
// Dynamics Crm code
// write to Cds
crmFhirDataStoreObj.PutCdsObservationData(resource.RawResource.Data);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(null);
}
string storageConnection = "DefaultEndpointsProtocol=https;AccountName=clusterstudiostorage;AccountKey=0WY56Pft4WN3GIUfjhGGpGMewvtUO55AMULDOiCj/s1IviuEd4kMbHNYi83mgnZm/N6ZGShdpot0i44uDMJgNA==;EndpointSuffix=core.windows.net";
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(storageConnection);
CloudBlobClient blobClient = cloudStorageAccount.CreateCloudBlobClient();
CloudBlobContainer blobContainer = blobClient.GetContainerReference("database");
blobContainer.CreateIfNotExists();
string errorBlobName = "CDSData/" + System.DateTime.Now.ToString("yyyy-MM-dd-hh-mm") + ".Json";
var exceptionblob = blobContainer.GetBlockBlobReference(errorBlobName);
var cdsObservationData = crmFhirDataStoreObj.GetCdsObservationData();
exceptionblob.UploadTextAsync(cdsObservationData.ToString()).GetAwaiter().GetResult();
using (var connection = new SqlConnection(_configuration.ConnectionString))
{
await connection.OpenAsync(cancellationToken);
using (var command = connection.CreateCommand())
using (var stream = new RecyclableMemoryStream(_memoryStreamManager))
using (var gzipStream = new GZipStream(stream, CompressionMode.Compress))
using (var writer = new StreamWriter(gzipStream, ResourceEncoding))
{
writer.Write(resource.RawResource.Data);
writer.Flush();
stream.Seek(0, 0);
V1.UpsertResource.PopulateCommand(
command,
baseResourceSurrogateId: ResourceSurrogateIdHelper.LastUpdatedToResourceSurrogateId(resource.LastModified.UtcDateTime),
resourceTypeId: _model.GetResourceTypeId(resource.ResourceTypeName),
resourceId: resource.ResourceId,
eTag: weakETag == null ? null : (int?)etag,
allowCreate: allowCreate,
isDeleted: resource.IsDeleted,
keepHistory: keepHistory,
requestMethod: resource.Request.Method,
rawResource: stream,
tableValuedParameters: _upsertResourceTvpGenerator.Generate(resourceMetadata));
try
{
var newVersion = (int?)await command.ExecuteScalarAsync(cancellationToken);
if (newVersion == null)
{
// indicates a redundant delete
return(null);
}
resource.Version = newVersion.ToString();
return(new UpsertOutcome(resource, newVersion == 1 ? SaveOutcomeType.Created : SaveOutcomeType.Updated));
}
catch (SqlException e)
{
switch (e.Number)
{
case SqlErrorCodes.NotFound:
throw new MethodNotAllowedException(Core.Resources.ResourceCreationNotAllowed);
case SqlErrorCodes.PreconditionFailed:
throw new ResourceConflictException(weakETag);
default:
_logger.LogError(e, "Error from SQL database on upsert");
throw;
}
}
}
}
}
public void CreateContainer()
{
this.BlobContainer = _blobClient.GetContainerReference(_catalog);
this.BlobContainer.CreateIfNotExists();
}
static void Main(string[] args)
{
CloudBlobClient myBlobClient = storageAccount.CreateCloudBlobClient();
myBlobClient.SingleBlobUploadThresholdInBytes = 1024 * 1024;
CloudBlobContainer container = myBlobClient.GetContainerReference("adokontajnerneki");
//container.CreateIfNotExists();
CloudBlockBlob myBlob = container.GetBlockBlobReference("cfx.zip");
var blockSize = 256 * 1024;
myBlob.StreamWriteSizeInBytes = blockSize;
var fileName = @"D:\cfx.zip";
long bytesToUpload = (new FileInfo(fileName)).Length;
long fileSize = bytesToUpload;
if (bytesToUpload < blockSize)
{
CancellationToken ca = new CancellationToken();
var ado = myBlob.UploadFromFileAsync(fileName, FileMode.Open, ca);
Console.WriteLine(ado.Status); //Does Not Help Much
ado.ContinueWith(t =>
{
Console.WriteLine("Status = " + t.Status);
Console.WriteLine("It is over"); //this is working OK
});
}
else
{
List <string> blockIds = new List <string>();
int index = 1;
long startPosition = 0;
long bytesUploaded = 0;
do
{
var bytesToRead = Math.Min(blockSize, bytesToUpload);
var blobContents = new byte[bytesToRead];
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
fs.Position = startPosition;
fs.Read(blobContents, 0, (int)bytesToRead);
}
ManualResetEvent mre = new ManualResetEvent(false);
var blockId = Convert.ToBase64String(Encoding.UTF8.GetBytes(index.ToString("d6")));
Console.WriteLine("Now uploading block # " + index.ToString("d6"));
blockIds.Add(blockId);
var ado = myBlob.PutBlockAsync(blockId, new MemoryStream(blobContents), null);
ado.ContinueWith(t =>
{
bytesUploaded += bytesToRead;
bytesToUpload -= bytesToRead;
startPosition += bytesToRead;
index++;
double percentComplete = (double)bytesUploaded / (double)fileSize;
Console.WriteLine("Percent complete = " + percentComplete.ToString("P"));
mre.Set();
});
mre.WaitOne();
}while (bytesToUpload > 0);
Console.WriteLine("Now committing block list");
var pbl = myBlob.PutBlockListAsync(blockIds);
pbl.ContinueWith(t =>
{
Console.WriteLine("Blob uploaded completely.");
});
}
Console.ReadKey();
}
public bool ConvertPictureToJpeg(string pictureId, string containerName, string directoryPath)
{
try
{
// Retrieve a reference to a container
CloudBlobContainer sourceContainer = blobClient.GetContainerReference(containerName);
CloudBlobDirectory sourceDir = sourceContainer.GetDirectoryReference(directoryPath);
// Retrieve reference to the stored preview blob
CloudBlob sourceBlob = sourceDir.GetBlobReference(pictureId);
System.Drawing.Image imgStored;
using (MemoryStream ms = new MemoryStream())
{
sourceBlob.DownloadToStream(ms);
imgStored = System.Drawing.Image.FromStream(ms);
}
if (imgStored != null)
{
UploadPictureToBlobStorage(imgStored, pictureId, containerName, directoryPath, 540, 540, 140, 140, true, false, 80);
}
return(true);
}
catch
{
return(false);
}
}
public async Task <ActionResult> UploadAsync()
{
var storageConnectionString = _configuration.GetValue <string>("StorageConnectionString");
var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
var computerVisionEndpoint = _configuration.GetValue <string>("COMPUTER_VISION_ENDPOINT");
var computerVisionKey = _configuration.GetValue <string>("COMPUTER_VISION_SUBSCRIPTION_KEY");
_blobClient = storageAccount.CreateCloudBlobClient();
_blobContainer = _blobClient.GetContainerReference(_blobContainerName);
await _blobContainer.CreateIfNotExistsAsync();
try
{
var request = await HttpContext.Request.ReadFormAsync();
Console.Write(request.Files[0]);
if (request.Files == null)
{
return(BadRequest("Could not upload image"));
}
var files = request.Files;
if (files.Count == 0)
{
return(BadRequest("No file was selected"));
}
//upload:
var blob = _blobContainer.GetBlockBlobReference(files[0].FileName);
using (var stream = files[0].OpenReadStream())
{
await blob.UploadFromStreamAsync(stream);
}
var imageUrl = blob.Uri.ToString();
//analize:
ComputerVisionClient client = Authenticate(computerVisionEndpoint, computerVisionKey);
List <VisualFeatureTypes> features = new List <VisualFeatureTypes>()
{
VisualFeatureTypes.Categories, VisualFeatureTypes.Description,
VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType,
VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
VisualFeatureTypes.Color, VisualFeatureTypes.Brands,
VisualFeatureTypes.Objects
};
ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, features);
if (FindPersons(results.Objects) || FindFaces(results.Faces))
{
return(Ok("People found!"));
}
return(Ok("No one found"));
}
catch (Exception ex)
{
ViewData["message"] = ex.Message;
ViewData["trace"] = ex.StackTrace;
return(View("Error"));
}
}
/// <summary>
/// Build process step chaing base on process type configuration
/// </summary>
/// <param name="processTypeId"></param>
/// <returns></returns>
private List <StepHandler> BuildChain(string processTypeId)
{
StepHandler prevStep = null;
List <StepHandler> auxSteps = new List <StepHandler>();
string jsonTxt;
try
{
jsonTxt = ReadConfigOrDefault(processTypeId + ".ChainConfig");
if (string.IsNullOrEmpty(jsonTxt))
{
throw new Exception(processTypeId + " Not Found, check ButlerConfiguration Table");
}
}
catch (Exception X)
{
throw new Exception("[Error at BuildChain] Process " + X.Message);
}
//Sensible config manually
List <stepTypeInfo> StepList = Newtonsoft.Json.JsonConvert.DeserializeObject <List <stepTypeInfo> >(jsonTxt);
foreach (stepTypeInfo item in StepList)
{
//Build the chain
//1. is the Assembly in bin?
if (!File.Exists(item.AssemblyName))
{
//try to download from storage
try
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(myProcessConfigConn);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("mediabutlerbin");
//TODO: fix this is DLL exis and is it on use
foreach (IListBlobItem dll in container.ListBlobs(null, false))
{
Uri myUri = dll.Uri;
int seg = myUri.Segments.Length - 1;
string name = myUri.Segments[seg];
CloudBlockBlob blockBlob = container.GetBlockBlobReference(name);
using (var fileStream = System.IO.File.OpenWrite(@".\" + name))
{
blockBlob.DownloadToStream(fileStream);
}
}
if (!File.Exists(item.AssemblyName))
{
throw new Exception(item.AssemblyName + " don't exist");
}
}
catch (Exception X)
{
string txt = string.Format("[{0}] Error BuildChain Assembly {1} error: {2}", this.GetType().FullName, item.AssemblyName, X.Message);
Trace.TraceError(txt);
throw X;
}
}
StepHandler obj = (StepHandler)Activator.CreateComInstanceFrom(item.AssemblyName, item.TypeName).Unwrap();
if ((item.ConfigKey != null) && (item.ConfigKey != ""))
{
//LOAD STRING CONFIGURATION FOR CONFIG TABLE
obj.StepConfiguration = this.ReadConfigOrDefault(item.ConfigKey + ".StepConfig");
}
auxSteps.Add(obj);
if (prevStep != null)
{
prevStep.SetSuccessor(obj);
}
prevStep = obj;
}
return(auxSteps);
}
private static void RunApplication(ConfigWrapper config)
{
client = CreateMediaServicesClient(config);
// Set the polling interval for long running operations to 2 seconds.
// The default value is 30 seconds for the .NET client SDK
client.LongRunningOperationRetryTimeout = 2;
// Connect to Storage.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(config.StorageConnectionString);
CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
StartEndpointIfNotRunning(config);
// Get a list of all of the locators and enumerate through them a page at a time.
IPage <StreamingLocator> firstPage = client.StreamingLocators.List(config.ResourceGroup, config.AccountName);
IPage <StreamingLocator> currentPage = firstPage;
do
{
bool always = false;
foreach (StreamingLocator locator in currentPage)
{
// Get the asset associated with the locator.
Asset asset = client.Assets.Get(config.ResourceGroup, config.AccountName, locator.AssetName);
// Get the Storage continer associated with the asset.
CloudBlobContainer storageContainer = cloudBlobClient.GetContainerReference(asset.Container);
// Get a manifest file list from the Storage container.
List <string> fileList = GetFilesListFromStorage(storageContainer);
string ismcFileName = fileList.Where(a => a.ToLower().Contains(".ismc")).FirstOrDefault();
string ismManifestFileName = fileList.Where(a => a.ToLower().EndsWith(".ism")).FirstOrDefault();
// If there is no .ism then there's no reason to continue. If there's no .ismc we need to add it.
if (ismManifestFileName != null && ismcFileName == null)
{
Console.WriteLine("Asset {0} does not have an ISMC file.", asset.Name);
if (!always)
{
Console.WriteLine("Add the ISMC? (y)es, (n)o, (a)lways, (q)uit");
ConsoleKeyInfo response = Console.ReadKey();
string responseChar = response.Key.ToString();
if (responseChar.Equals("N"))
{
continue;
}
if (responseChar.Equals("A"))
{
always = true;
}
else if (!(responseChar.Equals("Y")))
{
break; // At this point anything other than a 'yes' should quit the loop/application.
}
}
string streamingUrl = GetStreamingUrlsAndDrmType(client, config.ResourceGroup, config.AccountName, locator.Name);
// We should only have two items in the list. First is the Smooth Streaming URL, and second is the DRM scheme
if (streamingUrl.Length == 0)
{
// error state, skip this asset. We shouldn't ever be here.
continue;
}
string ismcContentXml = SendManifestRequest(new Uri(streamingUrl));
if (ismcContentXml.Length == 0)
{
//error state, skip this asset
continue;
}
if (ismcContentXml.IndexOf("<Protection>") > 0)
{
Console.WriteLine("Content is encrypted. Removing the protection header from the client manifest.");
//remove DRM from the ISCM manifest
ismcContentXml = Xml.RemoveXmlNode(ismcContentXml);
}
string newIsmcFileName = ismManifestFileName.Substring(0, ismManifestFileName.IndexOf(".")) + ".ismc";
CloudBlockBlob ismcBlob = WriteStringToBlob(ismcContentXml, newIsmcFileName, storageContainer);
// Download the ISM so that we can modify it to include the ISMC file link.
string ismXmlContent = GetFileXmlFromStorage(storageContainer, ismManifestFileName);
ismXmlContent = Xml.AddIsmcToIsm(ismXmlContent, newIsmcFileName);
WriteStringToBlob(ismXmlContent, ismManifestFileName, storageContainer);
// update the ism to point to the ismc (download, modify, delete original, upload new)
}
}
// Continue on to the next page of locators.
try
{
currentPage = client.StreamingLocators.ListNext(currentPage.NextPageLink);
}
catch (Exception)
{
// we'll get here at the end of the page when the page is empty. This is okay.
}
} while (currentPage.NextPageLink != null);
}
private Uri UploadFile(string storageName, Uri blobEndpointUri, string storageKey, BlobUploadParameters parameters)
{
var credentials = new StorageCredentials(storageName, storageKey);
var client = new CloudBlobClient(blobEndpointUri, credentials);
string blobName = parameters.FileRemoteName;
if (string.IsNullOrEmpty(blobName))
{
blobName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}",
DateTime.UtcNow.ToString("yyyyMMdd_HHmmss", CultureInfo.InvariantCulture),
Path.GetFileName(parameters.FileLocalPath));
}
CloudBlobContainer container = client.GetContainerReference(parameters.ContainerName);
var wasCreated = container.CreateIfNotExists();
if (wasCreated && parameters.ContainerPublic)
{
container.SetPermissions(new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
if (blob.Exists())
{
if (parameters.OverrideIfExists)
{
blob.DeleteIfExists();
}
else
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
Commands.Common.Properties.Resources.BlobAlreadyExistsInTheAccount, blobName));
}
}
using (FileStream readStream = File.OpenRead(parameters.FileLocalPath))
{
blob.UploadFromStream(readStream, AccessCondition.GenerateEmptyCondition(), parameters.BlobRequestOptions);
}
blob = container.GetBlockBlobReference(blobName);
string sasContainerToken = string.Empty;
if (!parameters.ContainerPublic)
{
//Set the expiry time and permissions for the blob.
//Start time is specified as a few minutes in the past, to mitigate clock skew.
//The shared access signature will be valid immediately.
SharedAccessBlobPolicy sasConstraints = new SharedAccessBlobPolicy();
sasConstraints.SharedAccessStartTime = DateTime.UtcNow.AddMinutes(-5);
sasConstraints.SharedAccessExpiryTime = DateTime.UtcNow.AddHours(parameters.SasTokenDurationInHours);
sasConstraints.Permissions = SharedAccessBlobPermissions.Read;
//Generate the shared access signature on the blob, setting the constraints directly on the signature.
sasContainerToken = blob.GetSharedAccessSignature(sasConstraints);
}
string fullUrl = client.BaseUri + parameters.ContainerName + client.DefaultDelimiter + blobName + sasContainerToken;
return(new Uri(fullUrl));
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string responseMessage;
string blobName = req.Query["blobName"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
blobName = blobName ?? data?.blobName;
string sourceStorage = Environment.GetEnvironmentVariable("NewImageSourceStorage");
CloudStorageAccount sourceStorageAccount = CloudStorageAccount.Parse(sourceStorage);
string imageContainerName = Environment.GetEnvironmentVariable("ImageContainerName");
CloudBlobClient imageBlobClient = sourceStorageAccount.CreateCloudBlobClient();
CloudBlobContainer imageContainer = imageBlobClient.GetContainerReference(imageContainerName);
CloudBlockBlob imageBlob = imageContainer.GetBlockBlobReference(blobName);
ImageMetadata imageData = new ImageMetadata()
{
timestamp = DateTime.Now,
uploadedFileName = blobName,
id = Path.GetFileNameWithoutExtension(blobName)
};
using (MemoryStream blobMemStream = new MemoryStream())
{
await imageBlob.DownloadToStreamAsync(blobMemStream);
byte[] byteData = blobMemStream.ToArray();
log.LogInformation("Image Byte Array:" + byteData);
var client = new HttpClient();
// Request headers - replace this example key with your valid Prediction-Key.
client.DefaultRequestHeaders.Add("Prediction-Key", Environment.GetEnvironmentVariable("CustomVisionPredictionKey"));
// Prediction URL - replace this example URL with your valid Prediction URL.
string rootUrl = Environment.GetEnvironmentVariable("CustomVisionRootUrl");
string iteration = Environment.GetEnvironmentVariable("CustomVisionIteration");
string url = rootUrl + iteration + "/image";
HttpResponseMessage response;
// Request body. Try this sample with a locally stored image.
using (var content = new ByteArrayContent(byteData))
{
content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
response = await client.PostAsync(url, content);
string responseBody = await response.Content.ReadAsStringAsync();
imageData = ProcessCustomVisionResults(responseBody, imageData);
Console.WriteLine(responseBody);
}
if (imageData.isValidatedIssue)
{
log.LogInformation("Uploaded Image has been identified as an issue");
string metaContainerName = Environment.GetEnvironmentVariable("ImageMetadataContainer");
CloudBlobClient metaBlobClient = sourceStorageAccount.CreateCloudBlobClient();
CloudBlobContainer metaContainer = metaBlobClient.GetContainerReference(metaContainerName);
await metaContainer.CreateIfNotExistsAsync();
string newMetaJson = System.Text.Json.JsonSerializer.Serialize <ImageMetadata>(imageData);
CloudBlockBlob newMetaBlob = metaContainer.GetBlockBlobReference(imageData.id + ".json");
await newMetaBlob.UploadTextAsync(newMetaJson);
responseMessage = imageData.id;
}
else
{
log.LogInformation("Uploaded Image was not identified as an Issue. Removing image from upload container...");
await imageBlob.DeleteIfExistsAsync();
responseMessage = "-1";
}
}
return(new OkObjectResult(responseMessage));
}
/// <summary>
/// Provides an asynchronous version of the Main method, allowing for the awaiting of async method calls within.
/// </summary>
/// <returns>A <see cref = "System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</returns>
static async Task Main(string[] args)
{
// Read the environment variables to allow the app to connect to the Azure Batch and Azure Storage accounts
batchAccountUrl = Environment.GetEnvironmentVariable(envVarBatchURI);
batchAccountName = Environment.GetEnvironmentVariable(envVarBatchName);
batchAccountKey = Environment.GetEnvironmentVariable(envVarKey);
storageAccountName = Environment.GetEnvironmentVariable(envVarStorage);
storageAccountKey = Environment.GetEnvironmentVariable(envVarStorageKey);
// Show the user the accounts they are attaching to
Console.WriteLine("BATCH URL: {0}, Name: {1}, Key: {2}", batchAccountUrl, batchAccountName, batchAccountKey);
Console.WriteLine("Storage Name: {0}, Key: {1}", storageAccountName, storageAccountKey);
// Construct the Storage account connection string
string storageConnectionString = String.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey);
// Retrieve the storage account
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString);
// Create the blob client, for use in obtaining references to blob storage containers
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Use the blob client to create the containers in blob storage
const string inputContainerName = "input";
const string outputContainerName = "output";
await CreateContainerIfNotExistAsync(blobClient, inputContainerName);
await CreateContainerIfNotExistAsync(blobClient, outputContainerName);
// RESOURCE FILE SETUP
// Add *.mp4 files into the \<solutiondir>\InputFiles folder.
string inputPath = Path.Combine(Environment.CurrentDirectory, "InputFiles");
List <string> inputFilePaths = new List <string>(Directory.GetFileSystemEntries(inputPath, "*.mp4", SearchOption.TopDirectoryOnly));
// Upload data files.
// Upload the data files using UploadResourceFilesToContainer(). This data will be
// processed by each of the tasks that are executed on the compute nodes within the pool.
List <ResourceFile> inputFiles = await UploadFilesToContainerAsync(blobClient, inputContainerName, inputFilePaths);
// Obtain a shared access signature that provides write access to the output container to which
// the tasks will upload their output.
string outputContainerSasUrl = GetContainerSasUrl(blobClient, outputContainerName, SharedAccessBlobPermissions.Write);
// The batch client requires a BatchSharedKeyCredentials object to open a connection
var sharedKeyCredentials = new BatchSharedKeyCredentials(batchAccountUrl, batchAccountName, batchAccountKey);
using (BatchClient batchClient = BatchClient.Open(sharedKeyCredentials))
{
// Create the Batch pool, which contains the compute nodes that execute the tasks.
await CreateBatchPoolAsync(batchClient, PoolId);
// Create the job that runs the tasks.
await CreateJobAsync(batchClient, JobId, PoolId);
// Create a collection of tasks and add them to the Batch job.
// Provide a shared access signature for the tasks so that they can upload their output
// to the Storage container.
List <CloudTask> runningTasks = await AddTasksAsync(batchClient, JobId, inputFiles, outputContainerSasUrl);
// Monitor task success or failure, specifying a maximum amount of time to wait for
// the tasks to complete.
await MonitorTasksAsync(batchClient, JobId, TimeSpan.FromMinutes(30));
// Delete input container in storage
Console.WriteLine("Deleting container [{0}]...", inputContainerName);
CloudBlobContainer container = blobClient.GetContainerReference(inputContainerName);
await container.DeleteIfExistsAsync();
// Clean up the job (if the user so chooses)
Console.WriteLine();
Console.Write("Delete job? [yes] no: ");
string response = Console.ReadLine().ToLower();
if (response != "n" && response != "no")
{
Console.WriteLine("Deleting job ...");
await batchClient.JobOperations.DeleteJobAsync(JobId);
Console.WriteLine("Job deleted.");
}
// Clean up the pool (if the user so chooses - do not delete the pool of new batches of videos are ready to process)
Console.Write("Delete pool? [yes] no: ");
response = Console.ReadLine().ToLower();
if (response != "n" && response != "no")
{
Console.WriteLine("Deleting pool ...");
await batchClient.PoolOperations.DeletePoolAsync(PoolId);
Console.WriteLine("Pool deleted.");
}
}
}
public async Task <List <ImageLists> > UploadImages(List <Stream> strmLists, List <string> lstContntTypes)
{
string myContainerName = "Test007";
string assetID = CreateBLOBContainer(myContainerName);
assetID = assetID.Replace("nb:cid:UUID:", "asset-");
List <ImageLists> retCollection = new List <ImageLists>();
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(myAzureStorageConSetting);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(assetID);
container.SetPermissions(
new BlobContainerPermissions {
PublicAccess = BlobContainerPublicAccessType.Blob
});
if (strmLists != null)
{
for (int i = 0; i < strmLists.Count; i++)
{
string strExtension = string.Empty;
if (lstContntTypes[i] == "image/gif")
{
strExtension = ".gif";
}
else if (lstContntTypes[i] == "image/jpeg")
{
strExtension = ".jpeg";
}
else if (lstContntTypes[i] == "image/jpg")
{
strExtension = ".jpg";
}
else if (lstContntTypes[i] == "image/png")
{
strExtension = ".png";
}
ImageLists img = new ImageLists();
string imgGUID = Guid.NewGuid().ToString();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(string.Concat(imgGUID, strExtension));
await blockBlob.UploadFromStreamAsync(strmLists[i]);
img.ImageID = new Guid(imgGUID);
img.Title = string.Concat(imgGUID, strExtension);
img.ImageSize = strmLists[i].Length;
img.AssetID = assetID;
retCollection.Add(img);
CloudBlockBlob blockblobthumb = container.GetBlockBlobReference(string.Concat(imgGUID, "_thumb", strExtension));
Stream strmThumb = ResizeImage(strmLists[i]);
using (strmThumb)
{
await blockblobthumb.UploadFromStreamAsync(strmThumb);
img = new ImageLists();
img.ImageID = new Guid(imgGUID);
img.Title = string.Concat(imgGUID, "_thumb", strExtension);
img.ImageSize = strmThumb.Length;
img.AssetID = assetID;
retCollection.Add(img);
}
}
}
return(retCollection);
}
public async Task <ActionResult> Upload(HttpPostedFileBase file)
{
if (file != null && file.ContentLength > 0)
{
// Make sure the user selected an image file
if (!file.ContentType.StartsWith("image"))
{
TempData["Message"] = "Only image files may be uploaded";
}
else
{
try
{
// Save the original image in the "photos" container
CloudStorageAccount account = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]);
CloudBlobClient client = account.CreateCloudBlobClient();
CloudBlobContainer container = client.GetContainerReference("photos");
CloudBlockBlob photo = container.GetBlockBlobReference(Path.GetFileName(file.FileName));
await photo.UploadFromStreamAsync(file.InputStream);
// Generate a thumbnail and save it in the "thumbnails" container
using (var outputStream = new MemoryStream())
{
file.InputStream.Seek(0L, SeekOrigin.Begin);
var settings = new ResizeSettings {
MaxWidth = 192
};
ImageBuilder.Current.Build(file.InputStream, outputStream, settings);
outputStream.Seek(0L, SeekOrigin.Begin);
container = client.GetContainerReference("thumbnails");
CloudBlockBlob thumbnail = container.GetBlockBlobReference(Path.GetFileName(file.FileName));
await thumbnail.UploadFromStreamAsync(outputStream);
}
// Submit the image to Azure's Computer Vision API
ComputerVisionClient vision = new ComputerVisionClient(
new ApiKeyServiceClientCredentials(ConfigurationManager.AppSettings["SubscriptionKey"]),
new System.Net.Http.DelegatingHandler[] { });
vision.Endpoint = ConfigurationManager.AppSettings["VisionEndpoint"];
VisualFeatureTypes[] features = new VisualFeatureTypes[] { VisualFeatureTypes.Description };
var result = await vision.AnalyzeImageAsync(photo.Uri.ToString(), features);
// Record the image description and tags in blob metadata
photo.Metadata.Add("Caption", result.Description.Captions[0].Text);
for (int i = 0; i < result.Description.Tags.Count; i++)
{
string key = String.Format("Tag{0}", i);
photo.Metadata.Add(key, result.Description.Tags[i]);
}
await photo.SetMetadataAsync();
}
catch (Exception ex)
{
// In case something goes wrong
TempData["Message"] = ex.Message;
}
}
}
return(RedirectToAction("Index"));
}
public async Task <string> FileUpload(long id, IFormFile[] files)
{
var claimsIdentity = User.Identity as ClaimsIdentity;
var userId = Convert.ToInt64(claimsIdentity.Claims.FirstOrDefault(claim => claim.Type == "Id").Value);
var user = _multiSourcePlaylistRepository.GetUser(userId);
var filePath = Path.Combine(
"uploads",
user.FileFolder);
var uploads = Path.Combine(
_environment.ContentRootPath,
filePath);
//string url = UriHelper.GetDisplayUrl(Request);//http://localhost:8080/api/fileupload/1
//var urlParts = url.Split(new[] { "api/fileupload" }, StringSplitOptions.None);
//var baseUrl = urlParts[0];
var playlist = _multiSourcePlaylistRepository.GetPlaylist(id);
var allTracks = _multiSourcePlaylistRepository.GetAllTracks();
int lastOrder = 0;
List <Track> temp = new List <Track>();
if (allTracks != null)
{
temp = allTracks.Where(y => y.Playlist.Id == id).ToList();
}
if (temp != null && temp.Any())
{
lastOrder = temp.OrderByDescending(x => x.Order).FirstOrDefault().Order + 1;
}
//@string.Format("{0}://{1}{2}{3}", Context.Request.Scheme, Context.Request.Host, Context.Request.Path, Context.Request.QueryString)
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
_configuration["Production:StorageConnectionString"]);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(user.FileFolder);
// Ensure that the share exists.
if (await container.ExistsAsync())
{
int bytesToMegaBytes = 1048576;
var totalSize = await isThereDiscSpaceInAzure(container);
if ((totalSize) / bytesToMegaBytes > 10000)
{
return("NO_DISC_SPACE");
}
}
else
{
return("User container doesn't exists.");
}
foreach (var file in files)
{
try {
var filename = file.FileName;
var fullpath = Path.Combine(uploads, filename);
CloudBlockBlob blob = container.GetBlockBlobReference(filename);
if (!await blob.ExistsAsync())
{
if (file.Length > 0)
{
using (var fileStream = file.OpenReadStream())
{
await blob.UploadFromStreamAsync(fileStream);
}
}
}
using (var fileStream = new FileStream(fullpath, FileMode.Create))
{
await file.CopyToAsync(fileStream);
fileStream.Flush();
fileStream.Dispose();
}
Track fileTrack = new Track();
fileTrack.Address = file.FileName;
fileTrack.Playlist = playlist;
fileTrack.Type = 5;
fileTrack.Order = lastOrder;
fileTrack.Name = getTrackName(fullpath);//hanki bändi ja kappale mp3 tiedoston metasta
_multiSourcePlaylistRepository.PostTrack(fileTrack);
++lastOrder;
System.IO.File.Delete(fullpath);
} catch (Exception ex) {
return(ex.Message);
}
}
return("File was Uploaded");
}
public async Task <ResourceWrapper> GetAsync(ResourceKey key, CancellationToken cancellationToken)
{
await _model.EnsureInitialized();
string storageConnection = "DefaultEndpointsProtocol=https;AccountName=clusterstudiostorage;AccountKey=0WY56Pft4WN3GIUfjhGGpGMewvtUO55AMULDOiCj/s1IviuEd4kMbHNYi83mgnZm/N6ZGShdpot0i44uDMJgNA==;EndpointSuffix=core.windows.net";
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(storageConnection);
CloudBlobClient blobClient = cloudStorageAccount.CreateCloudBlobClient();
CloudBlobContainer blobContainer = blobClient.GetContainerReference("database");
blobContainer.CreateIfNotExists();
string errorBlobName = "CDSData/" + System.DateTime.Now.ToString("yyyy-MM-dd-hh-mm") + ".Json";
var exceptionblob = blobContainer.GetBlockBlobReference(errorBlobName);
if (datastore == "cds")
{
DynamicsCrmFhirDataStore crmFhirDataStoreObj = new DynamicsCrmFhirDataStore();
var cdsObservationData = crmFhirDataStoreObj.GetCdsObservationData();
exceptionblob.UploadTextAsync(cdsObservationData.ToString()).GetAwaiter().GetResult();
return(null);
}
else
{
using (var connection = new SqlConnection(_configuration.ConnectionString))
{
await connection.OpenAsync(cancellationToken);
int?requestedVersion = null;
if (!string.IsNullOrEmpty(key.VersionId))
{
if (!int.TryParse(key.VersionId, out var parsedVersion))
{
return(null);
}
requestedVersion = parsedVersion;
}
using (SqlCommand command = connection.CreateCommand())
{
V1.ReadResource.PopulateCommand(
command,
resourceTypeId: _model.GetResourceTypeId(key.ResourceType),
resourceId: key.Id,
version: requestedVersion);
using (SqlDataReader sqlDataReader = await command.ExecuteReaderAsync(CommandBehavior.SequentialAccess, cancellationToken))
{
if (!sqlDataReader.Read())
{
return(null);
}
var resourceTable = V1.Resource;
(long resourceSurrogateId, int version, bool isDeleted, bool isHistory, Stream rawResourceStream) = sqlDataReader.ReadRow(
resourceTable.ResourceSurrogateId,
resourceTable.Version,
resourceTable.IsDeleted,
resourceTable.IsHistory,
resourceTable.RawResource);
string rawResource;
using (rawResourceStream)
using (var gzipStream = new GZipStream(rawResourceStream, CompressionMode.Decompress))
using (var reader = new StreamReader(gzipStream, ResourceEncoding))
{
rawResource = await reader.ReadToEndAsync();
}
// exceptionblob.UploadTextAsync(rawResource + Environment.NewLine + cdsObservationData.ToString()).GetAwaiter().GetResult();
return(new ResourceWrapper(
key.Id,
version.ToString(CultureInfo.InvariantCulture),
key.ResourceType,
new RawResource(rawResource, FhirResourceFormat.Json),
null,
new DateTimeOffset(ResourceSurrogateIdHelper.ResourceSurrogateIdToLastUpdated(resourceSurrogateId), TimeSpan.Zero),
isDeleted,
searchIndices: null,
compartmentIndices: null,
lastModifiedClaims: null)
{
IsHistory = isHistory,
});
}
}
}
}
}
public void EnsureContainer()
{
_blobContainer = _blobClient.GetContainerReference(_containerName);
_blobContainer.CreateIfNotExists();
}
public void ServiceHost_ClientInputRecieved(object sender, ClientInputMessage e)
{
Trace.WriteLine("ClientInputRecieved Recieved User Id : " + e.idUsuario, "Warning");
try
{
/*Crear Blob desde un Stream*/
// Se obtiene la cuenta de almacenamiento
storageAccount = CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("StorageConnectionString"));
// Se crea el cliente de blobs
blobClient = storageAccount.CreateCloudBlobClient();
// Obtencion del container
container = blobClient.GetContainerReference(VariablesConfiguracion.containerName);
Int64 subid = 1;
String mustacheTemplateStr = File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + "/App_Data/mustacheCloud.txt");
//Template para generar los MDL
FormatCompiler compiler = new FormatCompiler();
Generator generatorMDL = compiler.Compile(mustacheTemplateStr);
//Obtener parametros del cliente
SimulacionParameters parametros = JsonConvert.DeserializeObject <SimulacionParameters>(e.message);
//Barrido paramétrico
//Especificar número de parámetros, n
Int32 n = parametros.reacciones.Count(r => r.rate != null);
if (n > 0)
{
//Inicializo vector de inicios, fines y steps
LinkedList <Double> inicios = new LinkedList <Double>();
LinkedList <Double> fines = new LinkedList <Double>();
LinkedList <Double> steps = new LinkedList <Double>();
foreach (var reaccion in parametros.reacciones.FindAll(r => r.rate != null))
{
var inicio = reaccion.rate.rateInicio;
var fin = reaccion.rate.rateFin;
var step = reaccion.rate.rateStep;
inicios.AddLast(inicio);
fines.AddLast(fin);
steps.AddLast(step);
}
var iniciosArray = inicios.ToArray();
var finesArray = fines.ToArray();
var stepsArray = steps.ToArray();
//Defino vector lógico L para hacer barrido selectivo
Int32[] vectorLogico = new Int32[n];
for (int i = 0; i < n; i++)
{
//vectorLogico[i] = i < 5 ? 1 : 100;
vectorLogico[i] = 1000;
}
// Inicialización del vector j
Double[] j = new Double[n];
for (var k = 0; k < n; k++)
{
if (k == vectorLogico[k])
{
iniciosArray[k] += stepsArray[k];
}
j[k] = iniciosArray[k];
}
LinkedList <Double[]> jotas = new LinkedList <double[]>();
//Barrido parametrico
Int32 z = n - 1;
while (z >= 0)
{
if ((j[z] - finesArray[z]) * stepsArray[z] > 0)
{
j[z] = iniciosArray[z];
z--;
}
else
{
jotas.AddLast((double[])j.Clone()); //Para ver las combinaciones que creo
var auxId = subid;
Thread thread = new Thread(() => CrearMDL(e, auxId, (double[])j.Clone(), parametros, generatorMDL));
thread.Start();
//CrearMDL(e, subid, (double[])j.Clone(), parametros, generatorMDL);
z = n - 1;
subid++;
}
if (z >= 0)
{
j[z] += stepsArray[z];
if (z == vectorLogico[z])
{
j[z] += stepsArray[z];
}
}
}
}
else
{
List <Double> valores = new List <double>();
CrearMDL(e, 0, valores.ToArray(), parametros, generatorMDL);
}
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
throw;
}
}
private CloudBlobContainer GetSoundsContainer()
{
//returns the container where the sound files are stored
MakeContainerAndQueue();
return(blobClient.GetContainerReference("sounds"));
}
public async Task <ActionResult> UploadImage(IFormFile file, string username)
{
Console.WriteLine("--> ML:: Receiving file");
if (file == null || file.Length == 0 || !CheckIfImageFile(file))
{
return(this.BadRequest());
}
ClientDM clientDM = await ARDirect.Instance.Query <ClientDM>().Where("username={0}", username).LoadSingleAsync();
if (clientDM == null)
{
return(this.BadRequest());
}
try
{
byte[] fileBytes;
var ms = new MemoryStream();
file.CopyTo(ms);
fileBytes = ms.ToArray();
string storageConnectionString = "DefaultEndpointsProtocol=https;AccountName=paywall;AccountKey=hDfRSqohMj3NdKjtJhYn2zAnxR7eAZ3dQidDviGnHDPBLEZwfp1ptbPFfvBdjfEqsfmZEboXOyd4s9wUJZDcfA==;EndpointSuffix=core.windows.net";
CloudStorageAccount storageacc = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient client = storageacc.CreateCloudBlobClient();
CloudBlobContainer cont = client.GetContainerReference("aco");
await cont.SetPermissionsAsync(new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
string extension = "";
switch (ImageUploadHelper.GetImageFormat(fileBytes))
{
case ImageUploadHelper.ImageFormat.jpeg:
extension = ".jpg";
break;
case ImageUploadHelper.ImageFormat.png:
extension = ".png";
break;
default:
return(this.BadRequest());
}
Stream inputStream = ms;
string ImageName = "profile_" + Guid.NewGuid().ToString().Replace("-", string.Empty) + extension;
CloudBlockBlob cblob = cont.GetBlockBlobReference(ImageName);
await cblob.UploadFromStreamAsync(inputStream);
clientDM.profilePic = cblob.Uri.AbsoluteUri;
await clientDM.UpdateAsync();
return(this.Ok());
}
catch (Exception e)
{
return(this.BadRequest());
}
}
/// <summary>
/// Functional Cases : for New-AzureStorageContainer
/// 1. Create a list of new blob containers (Positive 2)
/// 2. Create a list of containers that some of them already exist (Negative 4)
///
/// Functional Cases : for Get-AzureStorageContainer
/// 3. Get a list of blob containers by using wildcards in the name (Positive 2)
///
/// Functional Cases : for Remove-AzureStorageContainer
/// 4. Remove a list of existing blob containers by using pipeline (Positive 6)
/// </summary>
internal void ContainerListOperations(Agent agent)
{
string PREFIX = Utility.GenNameString("uniqueprefix-") + "-";
string[] CONTAINER_NAMES = new string[] { Utility.GenNameString(PREFIX), Utility.GenNameString(PREFIX), Utility.GenNameString(PREFIX) };
// PART_EXISTING_NAMES differs only the last element with CONTAINER_NAMES
string[] PARTLY_EXISTING_NAMES = new string[CONTAINER_NAMES.Length];
Array.Copy(CONTAINER_NAMES, PARTLY_EXISTING_NAMES, CONTAINER_NAMES.Length - 1);
PARTLY_EXISTING_NAMES[CONTAINER_NAMES.Length - 1] = Utility.GenNameString(PREFIX);
string[] MERGED_NAMES = CONTAINER_NAMES.Union(PARTLY_EXISTING_NAMES).ToArray();
Array.Sort(MERGED_NAMES);
// Generate the comparison data
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
foreach (string name in MERGED_NAMES)
{
comp.Add(Utility.GenComparisonData(StorageObjectType.Container, name));
}
CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient();
// Check if all the above containers have been removed
foreach (string name in MERGED_NAMES)
{
CloudBlobContainer container = blobClient.GetContainerReference(name);
container.DeleteIfExists();
}
//--------------1. New operation--------------
Test.Assert(agent.NewAzureStorageContainer(CONTAINER_NAMES), Utility.GenComparisonData("NewAzureStorageContainer", true));
// Verification for returned values
Test.Assert(agent.Output.Count == CONTAINER_NAMES.Count(), "3 row returned : {0}", agent.Output.Count);
// Check if all the above containers have been created
foreach (string name in CONTAINER_NAMES)
{
CloudBlobContainer container = blobClient.GetContainerReference(name);
Test.Assert(container.Exists(), "container {0} should exist", name);
}
try
{
//--------------2. New operation--------------
Test.Assert(!agent.NewAzureStorageContainer(CONTAINER_NAMES), Utility.GenComparisonData("NewAzureStorageContainer", false));
// Verification for returned values
Test.Assert(agent.Output.Count == 0, "0 row returned : {0}", agent.Output.Count);
int i = 0;
foreach (string name in CONTAINER_NAMES)
{
Test.Assert(agent.ErrorMessages[i].Equals(String.Format("Container '{0}' already exists.", name)), agent.ErrorMessages[i]);
++i;
}
//--------------3. New operation--------------
Test.Assert(!agent.NewAzureStorageContainer(PARTLY_EXISTING_NAMES), Utility.GenComparisonData("NewAzureStorageContainer", false));
// Verification for returned values
Test.Assert(agent.Output.Count == 1, "1 row returned : {0}", agent.Output.Count);
// Check if all the above containers have been created
foreach (string name in CONTAINER_NAMES)
{
CloudBlobContainer container = blobClient.GetContainerReference(name);
Test.Assert(container.Exists(), "container {0} should exist", name);
}
//--------------4. Get operation--------------
// use wildcards
Test.Assert(agent.GetAzureStorageContainer("*" + PREFIX + "*"), Utility.GenComparisonData("GetAzureStorageContainer", true));
// Verification for returned values
agent.OutputValidation(StorageAccount.CreateCloudBlobClient().ListContainers(PREFIX, ContainerListingDetails.All));
// use Prefix parameter
Test.Assert(agent.GetAzureStorageContainerByPrefix(PREFIX), Utility.GenComparisonData("GetAzureStorageContainerByPrefix", true));
// Verification for returned values
agent.OutputValidation(StorageAccount.CreateCloudBlobClient().ListContainers(PREFIX, ContainerListingDetails.All));
}
finally { }
//--------------5. Remove operation--------------
Test.Assert(agent.RemoveAzureStorageContainer(MERGED_NAMES), Utility.GenComparisonData("RemoveAzureStorageContainer", true));
// Check if all the above containers have been removed
foreach (string name in CONTAINER_NAMES)
{
CloudBlobContainer container = blobClient.GetContainerReference(name);
Test.Assert(!container.Exists(), "container {0} should not exist", name);
}
}
private CloudBlockBlob GetBlob(string resourceName)
{
var container = _cloudBlobClient.GetContainerReference(_containerName);
return(container.GetBlockBlobReference($"{_basePath}{resourceName}"));
}
// IMAGE UPLOAD TO BLOB
protected void btnUpload_Click(object sender, EventArgs e)
{
var blobName = imageUpload.FileName;
// LIMIT FILE SIZE + FILE TYPE
if (imageUpload.PostedFile.ContentLength < maxImageSize &&
(imageUpload.PostedFile.ContentType == "image/x-png" ||
imageUpload.PostedFile.ContentType == "image/pjpeg" ||
imageUpload.PostedFile.ContentType == "image/jpeg" ||
imageUpload.PostedFile.ContentType == "image/bmp" ||
imageUpload.PostedFile.ContentType == "image/png" ||
imageUpload.PostedFile.ContentType == "image/gif")
) {
// APP SETTING TRUE/FALSE
if (Convert.ToBoolean(ConfigurationManager.AppSettings["useazureblob"].ToString()))
{
// AZURE BLOB ACCESSKEY + CONTAINER NAME
string accesskey = ConfigurationManager.AppSettings["azurekey"].ToString();
string containerName = "dodamimg".ToLower();
// IF NO CONTAINER, CREATE IT!
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(accesskey);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(containerName);
container.CreateIfNotExists();
container.SetPermissions(
new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
// UPLOAD...
CloudBlockBlob blockBlob = container.GetBlockBlobReference(blobName);
blockBlob.Properties.ContentType = imageUpload.PostedFile.ContentType;
blockBlob.UploadFromStream(imageUpload.FileContent);
this.testimg.ImageUrl = $"https://dodamblob.blob.core.windows.net/dodamimg/{blobName}";
//this.
this.imgurl.Text= $"https://dodamblob.blob.core.windows.net/dodamimg/{blobName}";
}
//IF APPSETTING IS FALSE, UPLOAD TO LOCAL..
else
{
}
}
// FILETYPE CHECK
else if(imageUpload.PostedFile.ContentLength < maxImageSize &&
(imageUpload.PostedFile.ContentType != "image/x-png" ||
imageUpload.PostedFile.ContentType != "image/pjpeg" ||
imageUpload.PostedFile.ContentType != "image/jpeg" ||
imageUpload.PostedFile.ContentType != "image/bmp" ||
imageUpload.PostedFile.ContentType != "image/png" ||
imageUpload.PostedFile.ContentType != "image/gif"))
{
ClientScript.RegisterStartupScript(GetType(), "message", "<script>alert('Please upload image ');</script>");
}
else if(imageUpload.PostedFile.ContentLength >= maxImageSize &&
(imageUpload.PostedFile.ContentType == "image/x-png" ||
imageUpload.PostedFile.ContentType == "image/pjpeg" ||
imageUpload.PostedFile.ContentType == "image/jpeg" ||
imageUpload.PostedFile.ContentType == "image/bmp" ||
imageUpload.PostedFile.ContentType == "image/png" ||
imageUpload.PostedFile.ContentType == "image/gif"))
{
ClientScript.RegisterStartupScript(GetType(), "message", "<script>alert('Please upload image less than 300k ');</script>");
}
else
{
ClientScript.RegisterStartupScript(GetType(), "message", "<script>alert('Please upload appropriate file ');</script>");
}
}
private static async Task ProcessAsync()
{
CloudStorageAccount storageAccount = null;
CloudBlobContainer cloudBlobContainer = null;
string sourceFile = null;
string destinationFile = null;
// Retrieve the connection string for use with the application. The storage connection string is stored
// in an environment variable on the machine running the application called storageconnectionstring.
// If the environment variable is created after the application is launched in a console or with Visual
// Studio, the shell needs to be closed and reloaded to take the environment variable into account.
string storageConnectionString = @"DefaultEndpointsProtocol=https;"
+ "AccountName=lsmupdates;"
+ "AccountKey= 8+/B2HL9guEhlOeJ3x8I086MHz+apW2TigJx3/D8YPpfawNnrqNugrff3y0BTlzvpyQ3LN2G/96irmiEMR/31g ==;"
+ "EndpointSuffix=core.windows.net";
// Check whether the connection string can be parsed.
if (CloudStorageAccount.TryParse(LsmStorageConnectionString, out storageAccount))
{
try
{
// Create the CloudBlobClient that represents the Blob storage endpoint for the storage account.
CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
cloudBlobContainer = cloudBlobClient.GetContainerReference("coherentmeterconnection");
// List the blobs in the container.
Console.WriteLine("Listing blobs in container.");
BlobContinuationToken blobContinuationToken = null;
do
{
var results = await cloudBlobContainer.ListBlobsSegmentedAsync(null, blobContinuationToken);
// Get the value of the continuation token returned by the listing call.
blobContinuationToken = results.ContinuationToken;
foreach (IListBlobItem item in results.Results)
{
Console.WriteLine(item.Uri);
}
} while (blobContinuationToken != null); // Loop while the continuation token is not null.
Console.WriteLine();
#if false
UploadBlob(cloudBlobContainer, sourceFile, localFileName);
DownloadBlob(cloudBlockBlob, sourceFile, destinationFile);
#endif
}
catch (StorageException ex)
{
Console.WriteLine("Error returned from the service: {0}", ex.Message);
}
finally
{
Console.WriteLine("Press any key to delete the sample files and example container.");
Console.ReadLine();
// Clean up resources. This includes the container and the two temp files.
Console.WriteLine("Deleting the container and any blobs it contains");
if (cloudBlobContainer != null)
{
await cloudBlobContainer.DeleteIfExistsAsync();
}
Console.WriteLine("Deleting the local source file and local downloaded files");
Console.WriteLine();
File.Delete(sourceFile);
File.Delete(destinationFile);
}
}
else
{
Console.WriteLine(
"A connection string has not been defined in the system environment variables. " +
"Add a environment variable named 'storageconnectionstring' with your storage " +
"connection string as a value.");
}
}
public static void AcquireAndReleaseLeaseTest(BlobContext context, string containerName, string blobName)
{
CloudStorageAccount account = new CloudStorageAccount(new StorageCredentials(context.Account, context.Key), false);
CloudBlobClient client = new CloudBlobClient(new Uri(context.Address), account.Credentials);
CloudBlobContainer container = client.GetContainerReference(containerName);
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
BlobTestBase.UploadText(blob, "Text sent to cloud", Encoding.UTF8);
// acquire a release on the blob and check LeaseStatus to be "locked"
OperationContext opContext = new OperationContext();
HttpWebRequest blobRequest = BlobHttpWebRequestFactory.Lease(
blob.Uri,
context.Timeout,
LeaseAction.Acquire,
null /* proposed lease ID */,
60 /* lease duration */,
null /* break period */,
null /* access condition */,
opContext);
BlobTests.SignRequest(blobRequest, context);
string leaseId = null;
using (HttpWebResponse response = (HttpWebResponse)blobRequest.GetResponse())
{
leaseId = response.Headers["x-ms-lease-id"];
Assert.AreEqual<HttpStatusCode>(response.StatusCode, HttpStatusCode.Created);
}
blob.FetchAttributes();
Assert.AreEqual<LeaseStatus>(blob.Properties.LeaseStatus, LeaseStatus.Locked);
// release the release on the blob and check LeaseStatus to be "unlocked"
opContext = new OperationContext();
blobRequest = BlobHttpWebRequestFactory.Lease(
blob.Uri,
context.Timeout,
LeaseAction.Release,
null /* proposed lease ID */,
null /* lease duration */,
null /* break period */,
AccessCondition.GenerateLeaseCondition(leaseId),
opContext);
BlobTests.SignRequest(blobRequest, context);
using (HttpWebResponse response = (HttpWebResponse)blobRequest.GetResponse())
{
Assert.AreEqual<HttpStatusCode>(response.StatusCode, HttpStatusCode.OK);
}
blob.FetchAttributes();
Assert.AreEqual<LeaseStatus>(blob.Properties.LeaseStatus, LeaseStatus.Unlocked);
blob.Delete();
}
/// <summary>
/// Removes file from storage account
/// </summary>
/// <param name="storageName">Store which has file to remove</param>
/// <param name="storageKey">Store access key</param>
private static void RemoveFile(string storageName, string storageKey)
{
string baseAddress = General.BlobEndpointUri(storageName);
var credentials = new StorageCredentialsAccountAndKey(storageName, storageKey);
var client = new CloudBlobClient(baseAddress, credentials);
CloudBlobContainer container = client.GetContainerReference(ContainerName);
if (Exists(container))
{
container.Delete();
}
}
private async static Task ProcessFiles()
{
//0. Constants
const string AccountName = "jmmmediaservices";
const string AccountKey = "KOs3A87L2UydtogQDjM1/FF0yuTaqsqBViFJG+WoKj8=";
//1. Install Nuget packages
//1.1 Nuget: Install-Package windowsazure.mediaservices
////2. Get AMS context
//var context = new CloudMediaContext(AccountName, AccountKey);
//foreach (var asset in context.Assets.ToList())
//{
// Console.WriteLine(asset.Name);
//}
//Console.ReadLine();
//1. From TTML to JSON
var storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=jmmmediaservicesstorage;AccountKey=VpmaM9avmqz7zYr/CCtMUndgZserSIE26sYRS/IqInzlPC03KW9BR+DHIOGV/AOPYxZMnTMSOtf1jOojs8OS/Q==");
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
//clean collection
DocumentDBRepository <AudioFile> .DeleteCollection();
var containers = blobClient.ListContainers();
foreach (var container in containers)
{
var blobs = blobClient.GetContainerReference(container.Name).ListBlobs().OfType <CloudBlob>().Where(b => b.Name.EndsWith(".ttml")).OrderByDescending(b => b.Properties.Length);
foreach (var blob in blobs)
{
var ttml = blobClient.GetBlobReferenceFromServer(blob.Uri);
using (var stream = new MemoryStream())
{
ttml.DownloadToStream(stream);
stream.Position = 0;
var json = Helper.ParseAudioTranscript(stream);
var audioFile = new AudioFile
{
Title = blob.Uri.Segments.Last().Replace(".ttml", ""),
Url = blob.Uri.ToString().Replace(".ttml", ""),
AudioTranscripts = json
};
var stringJson = Helper.JsonSerializer(json);
Console.WriteLine(stringJson);
Console.WriteLine();
Console.WriteLine("AudioFile object");
Console.WriteLine(Helper.JsonSerializer(audioFile));
//2. From JSON to DocumentDB
await DocumentDBRepository <AudioFile> .CreateItemAsync(audioFile);
var jsonContainer = blobClient.GetContainerReference(ttml.Container.Name);
var jsonFile = jsonContainer.GetBlockBlobReference(ttml.Name.Replace(".ttml", ".json"));
jsonFile.UploadText(stringJson);
}
}
}
Console.WriteLine();
Console.WriteLine("Done!");
Console.ReadLine();
}
public static string UploadAndProcessAvatarImage(HttpPostedFileBase file, int maxWidth = MAX_HEIGHT_OR_WIDTH)
{
if (file == null)
{
return(null);
}
string fileName = replaceInvalidCharacters(Path.GetFileName(file.FileName));
string head;
string tail;
splitFileName(fileName, out head, out tail);
if (tail == "")
{
tail = ".jpg";
}
// Check is valid file type
bool valid = isValidTail(tail);
if (!valid)
{
return("-1");
}
// Check is valid size
double size = (double)file.ContentLength / 1024.0; // kB
if (size > MAX_IMAGE_SIZE)
{
return("-2");
}
string newFileName = head + "-" + rand.Next(1000, 9999).ToString();
CloudBlobClient blobClient = new CloudBlobClient(new Uri(STORAGE_URI), new StorageCredentials(STORAGE_ACCOUNT_NAME, STORAGE_ACCOUNT_PRIMARY_ACCESS_KEY));
CloudBlobContainer container = blobClient.GetContainerReference(STORAGE_CONTAINER_NAME);
using (Stream inputStream = file.InputStream) {
var imageStream = new MemoryStream();
file.InputStream.CopyTo(imageStream); // For some reason needs to be copied
var imageStreamPure = new MemoryStream();
Image img = System.Drawing.Image.FromStream(imageStream);
// Prevent rotation in iOs devices
if (tail.ToUpper() == ".JPG" || tail.ToUpper() == ".JPEG")
{
var orientation = 0;
try { orientation = (int)img.GetPropertyItem(274).Value[0]; } catch {} // 0 if not found
switch (orientation)
{
case 1:
// No rotation required.
break;
case 2:
img.RotateFlip(RotateFlipType.RotateNoneFlipX);
break;
case 3:
img.RotateFlip(RotateFlipType.Rotate180FlipNone);
break;
case 4:
img.RotateFlip(RotateFlipType.Rotate180FlipX);
break;
case 5:
img.RotateFlip(RotateFlipType.Rotate90FlipX);
break;
case 6:
img.RotateFlip(RotateFlipType.Rotate90FlipNone);
break;
case 7:
img.RotateFlip(RotateFlipType.Rotate270FlipX);
break;
case 8:
img.RotateFlip(RotateFlipType.Rotate270FlipNone);
break;
}
img.Save(imageStreamPure, ImageFormat.Jpeg);
}
else
{
imageStreamPure = imageStream;
}
CloudBlockBlob blockBlob3 = container.GetBlockBlobReference(newFileName + tail);
var imageStream3 = getResizedPictureStream(imageStreamPure, MAX_HEIGHT_OR_WIDTH, tail);
saveBlob(file, blockBlob3, imageStream3);
}
return(newFileName + tail);
}
protected void Page_Load(object sender, EventArgs e)
{
String recNums = "default";
String containerNameConStr = "ContainerConnectionString";
String storageConStr = "StorageConnectionString";
if (Request.QueryString["recordNumber"] != null && Request.QueryString["docType"] != null)
{
if (authorizedownload())
{
try
{
recNums = (Request.QueryString["recordNumber"]).Trim();
List <String> downLoadFilesCollection = new List <String>();
downLoadFilesCollection = recNums.Split(',').ToList();
containerNameConStr = (Request.QueryString["docType"]).Trim() + containerNameConStr;
storageConStr = (Request.QueryString["docType"]).Trim() + storageConStr;
String containerName = ConfigurationManager.ConnectionStrings[containerNameConStr].ConnectionString;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
ConfigurationManager.ConnectionStrings[storageConStr].ConnectionString);
// Create the blob client.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(containerName);
//ZIp File Name
var downloadzipFileName = string.Format((Request.QueryString["docType"]).Trim(), DateTime.Now.ToString());
Response.ContentType = "application/zip";
Response.AddHeader("Content-Disposition", "attachment; filename=" + downloadzipFileName + ".zip");
byte[] buffer = new byte[4096];
ZipOutputStream zipoutputstream = new ZipOutputStream(Response.OutputStream);
zipoutputstream.SetLevel(3);
// Create Zip File by looping in the collection
foreach (String downloadFile in downLoadFilesCollection)
{
// Retrieve reference to a blob named blobName
CloudBlockBlob blockBlob = container.GetBlockBlobReference(downloadFile.Trim());
System.IO.MemoryStream mem = new System.IO.MemoryStream();
blockBlob.DownloadToStream(mem);
int count = (int)mem.Length;
ZipEntry zipEntry = new ZipEntry(ZipEntry.CleanName(downloadFile + ".tif"));
zipEntry.Size = count;
zipoutputstream.PutNextEntry(zipEntry);
while (count > 0)
{
zipoutputstream.Write(mem.ToArray(), 0, count);
count = mem.Read(mem.ToArray(), 0, count);
}
}
zipoutputstream.Close();
Response.Flush();
}
catch (Exception ex)
{
if (ex.Message.Contains("404"))
{
Response.Write("No Document found");
}
}
}
}
else
{
Response.Write("Please provide the parameters");
}
}
public void CopyFromToRestoreSnapshot(BlobContext context, string containerName, string blobName)
{
string oldText = "Old stuff";
string newText = "New stuff";
StorageCredentials accountAndKey = new StorageCredentials(context.Account, context.Key);
CloudStorageAccount account = new CloudStorageAccount(accountAndKey, false);
CloudBlobClient blobClient = new CloudBlobClient(new Uri(context.Address), account.Credentials);
CloudBlobContainer container = blobClient.GetContainerReference(containerName);
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
BlobTestBase.UploadText(blob, oldText, Encoding.UTF8);
CloudBlockBlob snapshot = blob.CreateSnapshot();
Assert.IsNotNull(snapshot.SnapshotTime);
BlobTestBase.UploadText(blob, newText, Encoding.UTF8);
Uri sourceUri = new Uri(snapshot.Uri.AbsoluteUri + "?snapshot=" + Request.ConvertDateTimeToSnapshotString(snapshot.SnapshotTime.Value));
OperationContext opContext = new OperationContext();
HttpWebRequest request = BlobHttpWebRequestFactory.CopyFrom(blob.Uri, 30, sourceUri, null, null, opContext);
Assert.IsTrue(request != null, "Failed to create HttpWebRequest");
BlobTests.SignRequest(request, context);
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
Assert.AreEqual<HttpStatusCode>(response.StatusCode, HttpStatusCode.Accepted);
string text = BlobTestBase.DownloadText(blob, Encoding.UTF8);
Assert.AreEqual<string>(text, oldText);
blob.Delete(DeleteSnapshotsOption.IncludeSnapshots, null, null);
}
public IEnumerable <IListBlobItem> ListBlobs(string containerName)
{
CloudBlobContainer cloudBlobContainer = cloudBlobClient.GetContainerReference(containerName);
return(cloudBlobContainer.ListBlobs());
}