private async Task SetEmptyNotificationDataEntity(string notificationId)
        {
            var notificationDataEntityUpdate = new UpdateNotificationDataEntity
            {
                PartitionKey = PartitionKeyNames.NotificationDataTable.SentNotificationsPartition,
                RowKey       = notificationId,
                Succeeded    = 0,
                Failed       = 0,
                Throttled    = 0,
                Unknown      = 0,
            };

            notificationDataEntityUpdate.IsCompleted = true;
            notificationDataEntityUpdate.SentDate    = DateTime.UtcNow;

            var operation = TableOperation.InsertOrMerge(notificationDataEntityUpdate);

            await CompanyCommunicatorDataFunction.notificationDataRepository.Table.ExecuteAsync(operation);
        }
        public async Task Run(
            [ServiceBusTrigger("company-communicator-data", Connection = "ServiceBusConnection")]
            string myQueueItem,
            int deliveryCount,
            DateTime enqueuedTimeUtc,
            string messageId,
            ILogger log,
            ExecutionContext context)
        {
            CompanyCommunicatorDataFunction.configuration = CompanyCommunicatorDataFunction.configuration ??
                                                            new ConfigurationBuilder()
                                                            .AddEnvironmentVariables()
                                                            .Build();

            // Simply initialize the variable for certain build environments and versions
            var maxMinutesOfRetryingDataFunction = 0;

            // If parsing fails, out variable is set to 0, so need to set the default
            if (!int.TryParse(CompanyCommunicatorDataFunction.configuration["MaxMinutesOfRetryingDataFunction"], out maxMinutesOfRetryingDataFunction))
            {
                maxMinutesOfRetryingDataFunction = 1440;
            }

            var messageContent = JsonConvert.DeserializeObject <ServiceBusDataQueueMessageContent>(myQueueItem);

            CompanyCommunicatorDataFunction.sentNotificationDataRepository = CompanyCommunicatorDataFunction.sentNotificationDataRepository
                                                                             ?? new SentNotificationDataRepository(CompanyCommunicatorDataFunction.configuration, isFromAzureFunction: true);

            CompanyCommunicatorDataFunction.notificationDataRepository = CompanyCommunicatorDataFunction.notificationDataRepository
                                                                         ?? this.CreateNotificationRepository(CompanyCommunicatorDataFunction.configuration);

            CompanyCommunicatorDataFunction.sendingNotificationDataRepository = CompanyCommunicatorDataFunction.sendingNotificationDataRepository
                                                                                ?? new SendingNotificationDataRepository(CompanyCommunicatorDataFunction.configuration, isFromAzureFunction: true);

            var sentNotificationDataEntities = await CompanyCommunicatorDataFunction.sentNotificationDataRepository.GetAllAsync(
                messageContent.NotificationId);

            if (sentNotificationDataEntities == null)
            {
                if (DateTime.UtcNow >= messageContent.InitialSendDate + TimeSpan.FromMinutes(maxMinutesOfRetryingDataFunction))
                {
                    await this.SetEmptyNotificationDataEntity(messageContent.NotificationId);

                    return;
                }

                await this.SendTriggerToDataFunction(CompanyCommunicatorDataFunction.configuration, messageContent);

                return;
            }

            var succeededCount = 0;
            var failedCount    = 0;
            var throttledCount = 0;
            var unknownCount   = 0;

            DateTime lastSentDateTime = DateTime.MinValue;

            foreach (var sentNotificationDataEntity in sentNotificationDataEntities)
            {
                if (sentNotificationDataEntity.StatusCode == (int)HttpStatusCode.Created)
                {
                    succeededCount++;
                }
                else if (sentNotificationDataEntity.StatusCode == (int)HttpStatusCode.TooManyRequests)
                {
                    throttledCount++;
                }
                else if (sentNotificationDataEntity.StatusCode == 0)
                {
                    unknownCount++;
                }
                else
                {
                    failedCount++;
                }

                if (sentNotificationDataEntity.SentDate != null &&
                    sentNotificationDataEntity.SentDate > lastSentDateTime)
                {
                    lastSentDateTime = sentNotificationDataEntity.SentDate;
                }
            }

            var notificationDataEntityUpdate = new UpdateNotificationDataEntity
            {
                PartitionKey = PartitionKeyNames.NotificationDataTable.SentNotificationsPartition,
                RowKey       = messageContent.NotificationId,
                Succeeded    = succeededCount,
                Failed       = failedCount,
                Throttled    = throttledCount,
                Unknown      = unknownCount,
            };

            // Purposefully exclude the unknown count because those messages may be sent later
            var currentMessageCount = succeededCount
                                      + failedCount
                                      + throttledCount;

            if (currentMessageCount == messageContent.TotalMessageCount ||
                DateTime.UtcNow >= messageContent.InitialSendDate + TimeSpan.FromMinutes(maxMinutesOfRetryingDataFunction))
            {
                notificationDataEntityUpdate.IsCompleted = true;
                notificationDataEntityUpdate.SentDate    = lastSentDateTime != DateTime.MinValue
                    ? lastSentDateTime
                    : DateTime.UtcNow;
            }
            else
            {
                await this.SendTriggerToDataFunction(CompanyCommunicatorDataFunction.configuration, messageContent);
            }

            var operation = TableOperation.InsertOrMerge(notificationDataEntityUpdate);

            await CompanyCommunicatorDataFunction.notificationDataRepository.Table.ExecuteAsync(operation);
        }