protected override async Task ExecuteCoreAsync(ReportExecutionContext context)
        {
            context.Log.LogInformation($"Started function execution: {DateTime.Now}");

            var storageConnString   = Environment.GetEnvironmentVariable("AzureWebJobsStorage");
            BlobServiceClient   bsc = new BlobServiceClient(storageConnString);
            BlobContainerClient bcc = bsc.GetBlobContainerClient(ContainerName);

            // create the container
            bcc.CreateIfNotExists();

            context.Log.LogInformation("Storage account accessed");

            DateTime to = DateTime.UtcNow;

            foreach (RepositoryConfiguration repositoryConfiguration in context.RepositoryConfigurations)
            {
                // retrieve the last accessed time for this repository
                BlobClient bc          = bcc.GetBlobClient($"{repositoryConfiguration.Owner}_{repositoryConfiguration.Name}");
                DateTime   lastDateRun = DateTime.UtcNow.AddDays(-1);

                try
                {
                    string content = StreamHelpers.GetContentAsString(bc.Download().Value.Content);
                    lastDateRun = DateTime.Parse(content);
                }
                catch
                {
                }

                context.Log.LogInformation("Last processed date for {0} is {1}", repositoryConfiguration, lastDateRun);

                string owner = repositoryConfiguration.Owner;
                string repo  = repositoryConfiguration.Name;

                context.Log.LogInformation("Processing repository {0}\\{1}", owner, repo);

                HtmlPageCreator emailBody = new HtmlPageCreator($"New items in {repo}");

                // get new issues
                RetrieveNewItems(context, CreateQueryForNewItems(repositoryConfiguration, IssueIsQualifier.Issue), lastDateRun, emailBody, "New issues");

                // get new PRs
                RetrieveNewItems(context, CreateQueryForNewItems(repositoryConfiguration, IssueIsQualifier.PullRequest), lastDateRun, emailBody, "New PRs");

                // get needs attention issues
                RetrieveNeedsAttentionIssues(context, repositoryConfiguration, emailBody);

                emailBody.AddContent($"<p>Last checked range: {lastDateRun} -> {to} </p>");

                context.Log.LogInformation("Sending email...");
                // send the email
                EmailSender.SendEmail(context.SendGridToken, context.FromAddress, emailBody.GetContent(), repositoryConfiguration.ToEmail, repositoryConfiguration.CcEmail, $"New issues in the {repo} repo as of {to.ToShortDateString()}", context.Log);

                context.Log.LogInformation("Email sent...");

                bc.Upload(StreamHelpers.GetStreamForString(to.ToUniversalTime().ToString()), overwrite: true);
                context.Log.LogInformation($"Persisted last event time for {repositoryConfiguration.Owner}\\{repositoryConfiguration.Name} as {to}");
            }
        }
        private async Task ProcessMessagesAsync(Microsoft.Azure.ServiceBus.Message message, CancellationToken token)
        {
            var msg = Encoding.UTF8.GetString(message.Body);

            string filePath = Path.GetTempFileName();

            try
            {
                BlobClient blob = _container.GetBlobClient(msg);

                BlobDownloadInfo download = blob.Download();
                using (FileStream file = System.IO.File.Create(filePath))
                {
                    download.Content.CopyTo(file);
                }


                var ratings = _serializationService.Deserialize(filePath);
            }
            catch (Exception ex)
            {
            }
            finally
            {
                await _queueClient.CompleteAsync(message.SystemProperties.LockToken);
            }
        }
        private MemoryStream GetFileFromStorage(string fileName, string container)
        {
            if (!initialized)
            {
                Initialize();
            }

            try
            {
                var containerTuple = ParseContainer(container);

                container = containerTuple.Item1;
                fileName  = string.Concat(containerTuple.Item2, fileName);

                BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient(container);
                BlobClient          blob = blobContainerClient.GetBlobClient(fileName);

                MemoryStream result = new MemoryStream();
                Response <BlobDownloadInfo> download = blob.Download();
                download.Value.Content.CopyTo(result);
                result.Position = 0;

                return(result);
            }
            catch (Exception)
            {
                return(null);
            }
        }
        private static void BlobStuff(string connectionString)
        {
            BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);

            Console.WriteLine($"Connecting to Blob Storage Account:\n\t { blobServiceClient.AccountName }\n");

            string containerName = "blobfromapp";

            var containerClient = blobServiceClient.GetBlobContainerClient(containerName);

            containerClient.CreateIfNotExists();

            string     fileName   = "myFile" + Guid.NewGuid().ToString() + ".txt";
            BlobClient blobClient = containerClient.GetBlobClient(fileName);

            Console.WriteLine($"Uploading to Blob Storage:\n\t { blobClient.Uri }\n");

            using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes("Prestifilippo rulez")))
            {
                blobClient.Upload(ms);
            }

            foreach (BlobItem item in containerClient.GetBlobs())
            {
                Console.WriteLine(item.Name);
            }

            Console.WriteLine($"Downloading blob");

            BlobDownloadInfo download = blobClient.Download();

            Console.WriteLine($"Complete");
        }
Пример #5
0
        private string DownloadBlob(string fileName)
        {
            // Define temporary file to download
            string downloadPath = _config.AzureBlob.TempDownloadFilePath;

            if (!Directory.Exists(downloadPath))
            {
                Directory.CreateDirectory(downloadPath);
            }

            string downloadFileName = Guid.NewGuid().ToString() + ".json";
            string downloadFilePath = Path.Combine(downloadPath, downloadFileName);

            // Get a reference to a blob
            BlobClient blobClient = _insightsContainerClient.GetBlobClient(fileName);

            _logger.Info($"Downloading blob { fileName } to { downloadFilePath }");

            // Download the blob's contents and save it to a temporary file
            BlobDownloadInfo download = blobClient.Download();

            using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath))
            {
                download.Content.CopyTo(downloadFileStream);
                downloadFileStream.Close();
            }

            return(downloadFilePath);
        }
        public static async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            var blobUrl  = Environment.GetEnvironmentVariable("BLOB_URL");
            var sasToken = GenerateSASToken();

            log.LogInformation("C# HTTP trigger function processed a request.");

            var blobUri = new UriBuilder(blobUrl)
            {
                Query = sasToken
            }.Uri;
            string content = "";

            var blobClient = new BlobClient(blobUri);

            using (var streamReader = new StreamReader(blobClient.Download().Value.Content)) {
                content = streamReader.ReadToEnd();
            }

            return(String.IsNullOrWhiteSpace(content)?
                   new BadRequestObjectResult("There is no content, or the SAS token is invalid"):
                   (ActionResult) new OkObjectResult($"Content: {content}"));
        }
Пример #7
0
        //---------------------------------------------------
        // Use Custom Request ID
        //---------------------------------------------------

        public void UseCustomRequestID()
        {
            string HOSTNAME = "";
            string APPNAME  = "";
            string USERID   = "";

            // <Snippet_UseCustomRequestID>

            var connectionString = Constants.connectionString;

            BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);

            BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient("demcontainer");

            BlobClient blobClient = blobContainerClient.GetBlobClient("testImage.jpg");

            string clientRequestID = String.Format("{0} {1} {2} {3}", HOSTNAME, APPNAME, USERID, Guid.NewGuid().ToString());

            using (HttpPipeline.CreateClientRequestIdScope(clientRequestID))
            {
                BlobDownloadInfo download = blobClient.Download();

                using (FileStream downloadFileStream = File.OpenWrite("C:\\testImage.jpg"))
                {
                    download.Content.CopyTo(downloadFileStream);
                    downloadFileStream.Close();
                }
            }

            // </Snippet_UseCustomRequestID>
        }
Пример #8
0
        public bool ExistsInStorageContainer(string path)
        {
            BlobContainerClient containerClient = GetFileShareContainer();
            BlobClient          blobClient      = containerClient.GetBlobClient(path);

            return(blobClient.Download().GetRawResponse().Status == 200);
        }
Пример #9
0
        public Stream CreateReadStream()
        {
            var stream = new MemoryStream();

            _blobClient.Download().Value.Content.CopyTo(stream);
            return(stream);
        }
Пример #10
0
    public Stream Download(Guid processIdentifier)
    {
        if (processIdentifier == Guid.Empty)
        {
            throw new ArgumentException("The parameter cannot be empty.", nameof(processIdentifier));
        }

        Process currentProcess = processRepository.Get(processIdentifier);

        if (currentProcess == null)
        {
            throw new Exception($"Cannot found process with identifier {processIdentifier}");
        }
        if (currentProcess.Blob == null)
        {
            throw new Exception($"Current blob have not associated blob.");
        }

        Blob currentBlob = blobRepository.Get(currentProcess.Id);

        BlobContainerClient blobContainerClient = new BlobContainerClient(blobStorageOptions.Value.ConnectionString, blobStorageOptions.Value.BlobContainerName);

        blobContainerClient.CreateIfNotExists();

        BlobClient blobClient = new BlobClient(blobStorageOptions.Value.ConnectionString, blobStorageOptions.Value.BlobContainerName, currentBlob.FileName);

        return(blobClient.Download().Value.Content);
    }
Пример #11
0
        /// <summary>
        /// Converts a blob client of a file to an XML document
        /// </summary>
        public static XDocument BlobClientToXml(BlobClient blobClient)
        {
            //parse string as xml doc
            var document = XDocument.Load(blobClient.Download().Value.Content);

            return(document);
        }
        public Stream Download(string fileName)
        {
            BlobClient       blobClient       = _containerClient.GetBlobClient(blobName: fileName);
            BlobDownloadInfo blobDownloadInfo = blobClient.Download();

            return(blobDownloadInfo.Content);
        }
Пример #13
0
        public AzureBlobsLogReader(BlobContainerClient blobsContainerClient, string fileName)
        {
            fileName   = AzureBlobsLogsInterface.PathFixer(fileName);
            _logClient = blobsContainerClient.GetBlobClient(fileName);
            var downloadRange = new HttpRange(0);

            _download = _logClient.Download(downloadRange);
        }
Пример #14
0
        public PSBlobDownloadInfo DownloadBlob()
        {
            //TODO: Please repalce with your real account
            BlobClient       client = new BlobClient("", "", "");
            BlobDownloadInfo info   = client.Download().Value;

            return(new PSBlobDownloadInfo(info));
        }
Пример #15
0
        public BlobDownloadInfo Download(string file)
        {
            BlobServiceClient   blobServiceClient = new BlobServiceClient(_connStr.Value.Storage);
            BlobContainerClient containerClient   = blobServiceClient.GetBlobContainerClient("webjob-pdf");
            BlobClient          blobClient        = containerClient.GetBlobClient(file);

            return(blobClient.Download());
        }
Пример #16
0
        static void Main(string[] args)
        {
            string downloadDirectory = args[0];

            // Create a BlobServiceClient object which will be used to create a container client
            BlobServiceClient blobServiceClient = new BlobServiceClient(AZURE_STORAGE_CONNECTION_STRING);

            // Create a unique name for the container
            string containerName = "startupfiles";

            // Create the container and return a container client object
            BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);

            List <BlobItem> blobs = containerClient.GetBlobs().ToList();

            // Download the blob files in parallel - maximum of 10 at a time }
            Parallel.ForEach(blobs, new ParallelOptions()
            {
                MaxDegreeOfParallelism = 10
            }, blob =>
            {
                string downloadFilePath   = Path.Combine(downloadDirectory, blob.Name);
                BlobClient blobClient     = containerClient.GetBlobClient(blob.Name);
                BlobDownloadInfo download = blobClient.Download();

                using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath))
                {
                    download.Content.CopyTo(downloadFileStream);
                    downloadFileStream.Close();
                }
            });

            string shareName = "startupfiles";

            ShareClient shareClient = new ShareClient(AZURE_FILES_CONNECTION_STRING, shareName);

            if (shareClient.Exists())
            {
                ShareDirectoryClient shareDirectoryClient = shareClient.GetRootDirectoryClient();

                List <ShareFileItem> items = shareDirectoryClient.GetFilesAndDirectories().ToList();
                foreach (ShareFileItem item in items)
                {
                    if (!item.IsDirectory)
                    {
                        string                downloadFilePath = Path.Combine(downloadDirectory, item.Name);
                        ShareFileClient       shareFileClient  = shareDirectoryClient.GetFileClient(item.Name);
                        ShareFileDownloadInfo download         = shareFileClient.Download();
                        using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath))
                        {
                            download.Content.CopyTo(downloadFileStream);
                            downloadFileStream.Close();
                        }
                    }
                }
            }
        }
Пример #17
0
        public int TransferAzureBlobFromPatternToDirectory(string prefixPattern, string destPath)
        {
            string continuationToken = null;
            int    rtnVal            = SetParameters();

            int?segmentSize = null;

            if (rtnVal != 0)
            {
                return(rtnVal);
            }

            BlobContainerClient blobContainerClient = new BlobContainerClient(storageConnectionString, blobContainerName);

            try
            {
                // Call the listing operation and enumerate the result segment.
                // When the continuation token is empty, the last segment has been returned
                // and execution can exit the loop.
                do
                {
                    var resultSegment = blobContainerClient.GetBlobs(prefix: prefixPattern).AsPages(continuationToken, segmentSize);


                    foreach (Azure.Page <BlobItem> blobPage in resultSegment)
                    {
                        foreach (BlobItem blobItem in blobPage.Values)
                        {
                            //Console.WriteLine("Blob name: {0}", blobItem.Name);
                            BlobClient blobClient = new BlobClient(storageConnectionString, blobContainerName, blobItem.Name);

                            // Download the blob's contents and save it to a file
                            BlobDownloadInfo download    = blobClient.Download();
                            string           outFileName = Path.Combine(destPath, Path.GetFileName(blobItem.Name));

                            using (FileStream file = File.OpenWrite($"{outFileName}"))
                            {
                                download.Content.CopyTo(file);
                            }
                        }

                        // Get the continuation token and loop until it is empty.
                        continuationToken = blobPage.ContinuationToken;
                        //Console.WriteLine();
                    }
                } while (continuationToken != "");
            }
            catch (RequestFailedException e)
            {
                errorMsg = e.Message;
                //Console.WriteLine(e.Message);
                //Console.ReadLine();
                //throw;
            }

            return(rtnVal);
        }
Пример #18
0
#pragma warning disable CA1822 // Does not acces instance data can be marked static.
        public virtual async Task <Segment> BuildSegment(
#pragma warning restore CA1822 // Can't mock static methods in MOQ.
            bool async,
            string manifestPath,
            SegmentCursor cursor = default)
        {
            // Models we need for later
            List <Shard>   shards     = new List <Shard>();
            DateTimeOffset dateTime   = BlobChangeFeedExtensions.ToDateTimeOffset(manifestPath).Value;
            int            shardIndex = cursor?.ShardIndex ?? 0;

            // Download segment manifest
            BlobClient       blobClient = _containerClient.GetBlobClient(manifestPath);
            BlobDownloadInfo blobDownloadInfo;

            if (async)
            {
                blobDownloadInfo = await blobClient.DownloadAsync().ConfigureAwait(false);
            }
            else
            {
                blobDownloadInfo = blobClient.Download();
            }

            // Parse segment manifest
            JsonDocument jsonManifest;

            if (async)
            {
                jsonManifest = await JsonDocument.ParseAsync(blobDownloadInfo.Content).ConfigureAwait(false);
            }
            else
            {
                jsonManifest = JsonDocument.Parse(blobDownloadInfo.Content);
            }

            int i = 0;

            foreach (JsonElement shardJsonElement in jsonManifest.RootElement.GetProperty("chunkFilePaths").EnumerateArray())
            {
                string shardPath = shardJsonElement.ToString().Substring("$blobchangefeed/".Length);
                Shard  shard     = await _shardFactory.BuildShard(
                    async,
                    shardPath,
                    cursor?.ShardCursors?[i])
                                   .ConfigureAwait(false);

                shards.Add(shard);
                i++;
            }

            return(new Segment(
                       shards,
                       shardIndex,
                       dateTime));
        }
        public static void Run([BlobTrigger("conversationkm-raw/{name}", Connection = "conversationstoragev2")] Stream myBlob, string name, ILogger log)
        {
            log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");

            List <EventData> eds = null;

            try
            {
                BotFrameworkDataExtractor de = new BotFrameworkDataExtractor();
                eds = de.ExtractFromBlob(myBlob);
            }
            catch { }

            if (eds != null)
            {
                BlobServiceClient   blobServiceClient   = new BlobServiceClient(Environment.GetEnvironmentVariable("conversationstoragev2"));
                BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient(Environment.GetEnvironmentVariable("outputContainerName"));

                foreach (EventData ed in eds)
                {
                    BlobClient blobClient = blobContainerClient.GetBlobClient($"{ed.ConversationId}.json");

                    try
                    {
                        BlobDownloadInfo download = blobClient.Download();
                        using (StreamReader reader = new StreamReader(download.Content))
                        {
                            string       content = reader.ReadToEnd();
                            Conversation existingConversation = JsonConvert.DeserializeObject <Conversation>(content);

                            existingConversation.Messages.Add(ed);

                            existingConversation.Messages.Sort((x, y) => x.EventTime.CompareTo(y.EventTime));

                            UploadConversation(existingConversation, blobClient);
                        }
                    }
                    catch (Azure.RequestFailedException ex)
                    {
                        if (ex.Status == 404)
                        {
                            Conversation conversation = new Conversation()
                            {
                                ConversationId = ed.ConversationId
                            };
                            conversation.Messages.Add(ed);

                            UploadConversation(conversation, blobClient);
                        }
                    }
                }
            }
        }
Пример #20
0
        private BlobDownloadInfo DownloadContentItem(BlobClient blobClient)
        {
            var response = blobClient.Download();

            if (response == null)
            {
                return(null);
            }
            var blobDownloadInfo = response.Value;

            return(blobDownloadInfo);
        }
Пример #21
0
        static void Main(string[] args)
        {
            try
            {
                BlobServiceClient   blobServiceClient = new BlobServiceClient(connString);
                BlobContainerClient containerClient   = blobServiceClient.GetBlobContainerClient(containerName);
                containerClient.CreateIfNotExists(); //Creating Container

                #region Code
                //Check Existence
                //if(!containerClient.Exists())
                //{
                //    containerClient = blobServiceClient.CreateBlobContainer(containerName);
                //}
                #endregion

                File.WriteAllText(localFilePath, "This is a blob");

                BlobClient blobClient = containerClient.GetBlobClient(fileName); //Getting Blob

                //Check for blobclient existence
                if (!blobClient.Exists())
                {
                    using (FileStream uploadFileStream = File.OpenRead(localFilePath))
                    {
                        blobClient.UploadAsync(uploadFileStream);
                    }
                }


                foreach (BlobItem item in containerClient.GetBlobs())
                {
                    BlobClient       blbClient        = containerClient.GetBlobClient(item.Name);
                    BlobDownloadInfo download         = blbClient.Download();
                    string           downloadFilePath = Path.Combine("../downloadeddata/", item.Name);

                    using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath))
                    {
                        download.Content.CopyToAsync(downloadFileStream);
                        downloadFileStream.Close();
                    }
                }



                Console.ReadLine();
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception.Message);
            }
        }
Пример #22
0
        public void DownloadFile()
        {
            string connectionString       = "DefaultEndpointsProtocol=https;AccountName=polichecksvc;AccountKey=+qitaIPghvVZQIm410FXCmeRJaHet9Ykj9G343ZSGbeyvaMpFCkEKZSwqiJwDMz/u0gpyihfzPmpqf7k54F9dQ==;EndpointSuffix=core.windows.net";
            string containerName          = "blobtest";
            BlobContainerClient container = new BlobContainerClient(connectionString, containerName);
            BlobClient          blob      = container.GetBlobClient("hello.docx");
            BlobDownloadInfo    download  = blob.Download();

            using (FileStream file = File.OpenWrite(@"C:\Users\v-qiazhe\Desktop\ttt.docx"))
            {
                download.Content.CopyTo(file);
            }
        }
Пример #23
0
        public BlobDownloadInfo ShowImage(string file)
        {
            BlobServiceClient   blobServiceClient = new BlobServiceClient(_connStr.Value.Storage);
            BlobContainerClient containerClient   = blobServiceClient.GetBlobContainerClient("images-staging");
            BlobClient          blobClient        = containerClient.GetBlobClient(file);

            if (!blobClient.Exists())
            {
                throw new FileNotFoundException("Blob not found", file);
            }

            return(blobClient.Download());
        }
Пример #24
0
        /// <summary>
        /// Reads the signing certificate from a location.
        /// Supported locations: Blob storage, File, Local, KeyVault.
        /// </summary>
        /// <param name="certificate"></param>
        /// <param name="location"></param>
        /// <param name="log"></param>
        /// <returns>x509 certificate without private key</returns>
        private static X509Certificate ReadCertificate(string certificate, Location location, ILogger log)
        {
            log.LogInformation($"Reading certificate from {location}...");

            X509Certificate x509 = null;

            try
            {
                if (location == Location.File)
                {
                    x509 = DotNetUtilities.FromX509Certificate(
                        System.Security.Cryptography.X509Certificates.X509Certificate.CreateFromCertFile(certificate));
                }

                if (location == Location.Local)
                {
                    using (TextReader reader = new StringReader(certificate))
                    {
                        Org.BouncyCastle.OpenSsl.PemReader pemReader = new Org.BouncyCastle.OpenSsl.PemReader(reader);
                        x509 = (X509Certificate)pemReader.ReadObject();
                    };
                }

                if (location == Location.Blob)
                {
                    blobClient = new BlobClient(blobConnectionString, blobContainerName, certificate);
                    BlobDownloadInfo download = blobClient.Download();
                    using (TextReader reader = new StreamReader(download.Content))
                    {
                        Org.BouncyCastle.OpenSsl.PemReader pemReader = new Org.BouncyCastle.OpenSsl.PemReader(reader);
                        x509 = (X509Certificate)pemReader.ReadObject();
                    };
                }

                if (location == Location.KeyVault)
                {
                    var client = new CertificateClient(new Uri($"https://{keyVaultName}.vault.azure.net"), new DefaultAzureCredential());
                    keyVaultCertificate = client.GetCertificate(certificate);
                    x509 = new Org.BouncyCastle.X509.X509CertificateParser().ReadCertificate(keyVaultCertificate.Cer);
                }
            }
            catch (Exception ex)
            {
                log.LogError(ex.Message);
            }

            log.LogInformation($"Finished reading certificate {x509.SubjectDN} from {location}.");

            return(x509);
        }
Пример #25
0
        /// <summary>
        /// Downloads the next block.
        /// <returns>Number of bytes that were downloaded</returns>
        /// </summary>
        private async Task DownloadBlock(bool async, CancellationToken cancellationToken)
        {
            Response <BlobDownloadInfo> response;
            HttpRange range = new HttpRange(_offset, _blockSize);

            response = async
                ? await _blobClient.DownloadAsync(range, cancellationToken : cancellationToken).ConfigureAwait(false)
                : _blobClient.Download(range);

            _stream            = response.Value.Content;
            _offset           += response.Value.ContentLength;
            _lastDownloadBytes = response.Value.ContentLength;
            _blobLength        = GetBlobLength(response);
        }
Пример #26
0
        private void ProcessBlobEmails(List <Models.EmailMetrics> emailMetrics, BlobClient blobClient)
        {
            BlobDownloadInfo emailBlob = blobClient.Download();

            using (var reader = new StreamReader(emailBlob.Content))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    JsonDocument jsonObj = JsonDocument.Parse(line);

                    // extract and count up recipients
                    var totalRecipients = 0;
                    try
                    {
                        totalRecipients += jsonObj.RootElement.GetProperty("toRecipients").GetArrayLength();
                    }
                    catch { }
                    try
                    {
                        totalRecipients += jsonObj.RootElement.GetProperty("ccRecipients").GetArrayLength();
                    }
                    catch { }
                    try
                    {
                        totalRecipients += jsonObj.RootElement.GetProperty("bccRecipients").GetArrayLength();
                    }
                    catch { }

                    var emailMetric = new Models.EmailMetrics();
                    try
                    {
                        emailMetric.Email = jsonObj.RootElement.GetProperty("sender").GetProperty("emailAddress").GetProperty("address").GetString();
                    }
                    catch { }
                    emailMetric.RecipientsToEmail = totalRecipients;

                    // if already have this sender...
                    var existingMetric = emailMetrics.FindLast(metric => metric.Email == emailMetric.Email);
                    if (existingMetric != null)
                    {
                        existingMetric.RecipientsToEmail += emailMetric.RecipientsToEmail;
                    }
                    else
                    {
                        emailMetrics.Add(emailMetric);
                    }
                }
            }
        }
        static string ReadFromStorageBlob(string fname)
        {
            string              conString         = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING");
            BlobServiceClient   blobServiceClient = new BlobServiceClient(conString);
            string              containerName     = Environment.GetEnvironmentVariable("AzStorageContainerName");
            BlobContainerClient containerClient   = blobServiceClient.GetBlobContainerClient(containerName);

            BlobClient blobClient = containerClient.GetBlobClient(fname);

            // Download the blob content.
            BlobDownloadInfo download = blobClient.Download();
            StreamReader     reader   = new StreamReader(download.Content);

            logger.LogInformation($"ReadFromStorageBlob: Read source index data from Az Storage: {fname}");
            return(reader.ReadToEnd());
        }
        public async Task StoreDataTestAsync()
        {
            string          fileName       = "storageTest.txt";
            string          expected       = "StoreDataTest text for testing";
            string          actual         = "";
            IStorageService storageService = new BlobStorageService(_connectionString, _testContainerName);
            await storageService.StoreDataAsync(expected, fileName);

            BlobClient       blobClient = _blobContainerClient.GetBlobClient(fileName);
            BlobDownloadInfo download   = blobClient.Download();

            using (StreamReader sr = new StreamReader(download.Content))
            {
                actual = sr.ReadToEnd();
            }
            Assert.Equal(expected, actual);
        }
Пример #29
0
        public async void DownloadFile(BlobClient blobClient)
        {
            // Download the blob to a local file
            // Append the string "DOWNLOAD" before the .txt extension so you can see both files in MyDocuments
            //var localFilePath = @"D:\NewDownloads\downloadedfromazure\downloadedfile_" + Guid.NewGuid() + "_.pdf";
            var localFilePath = @"D:\NewDownloads\downloadedfromazure";

            Console.WriteLine("\nDownloading blob to\n\t{0}\n", localFilePath);

            // Download the blob's contents and save it to a file
            BlobDownloadInfo download = blobClient.Download();

            FileStream downloadFileStream = File.OpenWrite(localFilePath);
            await download.Content.CopyToAsync(downloadFileStream);

            downloadFileStream.Close();
        }
Пример #30
0
        public async Task IndexContentFiles()
        {
            BlobContainerClient container =
                new BlobContainerClient(config.ConnectionString, config.Container);

            await container.CreateIfNotExistsAsync();

            await foreach (BlobItem blobItem in container.GetBlobsAsync())
            {
                if (blobItem.Name.EndsWith("index.md"))
                {
                    logger.LogInformation($"Indexing {blobItem.Name}");
                    var blobClient = new BlobClient(config.ConnectionString, config.Container, blobItem.Name);
                    var reader     = new StreamReader(blobClient.Download().Value.Content);
                    var post       = ReadPost(reader).Result;
                    Posts.Add(post);
                }
            }

            Posts = Posts.OrderByDescending(x => x.PublicationDate).ToList();
        }