public async Task <Tuple <bool, CMPStorageError> > DeleteQueueAsync(CMPQueueStorageOptions queueStorageOptions =
                                                                            null)
        {
            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                var couldDelete = false;
                if (queueStorageOptions == null)
                {
                    couldDelete = await _queueReference.DeleteIfExistsAsync();
                }
                else
                {
                    couldDelete = await _queueReference.DeleteIfExistsAsync(queueStorageOptions.QueueRequestOptions,
                                                                            queueStorageOptions.OperationContext,
                                                                            _tokenSource.Token);
                }

                return(new Tuple <bool, CMPStorageError>(couldDelete, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <int> GetMessagesCountAsync(CMPQueueStorageOptions queueStorageOptions)
        {
            try
            {
                if (_queueReference == null)
                {
                    return(-1);
                }

                if (queueStorageOptions == null)
                {
                    await _queueReference.FetchAttributesAsync();
                }
                else
                {
                    await _queueReference.FetchAttributesAsync(queueStorageOptions.QueueRequestOptions,
                                                               queueStorageOptions.OperationContext,
                                                               _tokenSource.Token);
                }

                return((int)(_queueReference.ApproximateMessageCount));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(-1);
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > AddMessageAsync(string messageString,
                                                                           string popupTokenString,
                                                                           CMPQueueStorageOptions queueStorageOptions =
                                                                           null)
        {
            if (string.IsNullOrEmpty(messageString) == true)
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                CloudQueueMessage queueMessage = null;
                if (string.IsNullOrEmpty(popupTokenString) == true)
                {
                    queueMessage = new CloudQueueMessage(messageString);
                }
                else
                {
                    queueMessage = new CloudQueueMessage(messageString, popupTokenString);
                }

                if (queueStorageOptions == null)
                {
                    await _queueReference.AddMessageAsync(queueMessage);
                }
                else
                {
                    await _queueReference.AddMessageAsync(queueMessage, queueStorageOptions.TimeToLive,
                                                          queueStorageOptions.VisibilityTimeoutOrDelay,
                                                          queueStorageOptions.QueueRequestOptions,
                                                          queueStorageOptions.OperationContext, _tokenSource.Token);
                }

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (OperationCanceledException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > UpdateMessageAsync(string updateMessageString,
                                                                              TimeSpan visibilityTimeOut,
                                                                              CMPQueueStorageOptions
                                                                              queueStorageOptions = null)
        {
            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                var cloudMessage = await _queueReference.GetMessageAsync();

                cloudMessage?.SetMessageContent(updateMessageString);

                if (queueStorageOptions == null)
                {
                    await _queueReference.UpdateMessageAsync(cloudMessage, visibilityTimeOut,
                                                             MessageUpdateFields.Content | MessageUpdateFields.Visibility);
                }
                else
                {
                    await _queueReference.UpdateMessageAsync(cloudMessage, visibilityTimeOut,
                                                             MessageUpdateFields.Content | MessageUpdateFields.Visibility,
                                                             queueStorageOptions.QueueRequestOptions,
                                                             queueStorageOptions.OperationContext, _tokenSource.Token);
                }

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (OperationCanceledException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > UpdateMessageAsync(string messageString,
                                                                              string messageIdString,
                                                                              string popupTokenString,
                                                                              CMPQueueStorageOptions queueStorageOptions)
        {
            if (queueStorageOptions == null)
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            if ((string.IsNullOrEmpty(messageIdString) == true) || (string.IsNullOrEmpty(popupTokenString) == true))
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                CloudQueueMessage queueMessage = new CloudQueueMessage(messageIdString, popupTokenString);
                queueMessage.SetMessageContent((queueStorageOptions.MessageUpdateFields ==
                                                MessageUpdateFields.Content) ? messageString : string.Empty);

                await _queueReference.UpdateMessageAsync(queueMessage, queueStorageOptions.VisibilityTimeoutOrDelay,
                                                         queueStorageOptions.MessageUpdateFields);

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (OperationCanceledException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > AddStreamToBlobAsync(Stream blobStream, string blobNameString,
                                                                                CMPBlobStorageOptions
                                                                                blobStorageOptions = null)
        {
            if (blobStream == null)
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            if (string.IsNullOrEmpty(blobNameString) == true)
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            try
            {
                var blobReference = PrepareBlockBlobReference(blobNameString);
                if (blobReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                if (blobStorageOptions == null)
                {
                    await blobReference.UploadFromStreamAsync(blobStream, blobStream.Length);
                }
                else
                {
                    await blobReference.UploadFromStreamAsync(blobStream, blobStream.Length,
                                                              blobStorageOptions.AccessCondition,
                                                              blobStorageOptions.BlobRequestOptions,
                                                              blobStorageOptions.OperationContext, _tokenSource.Token);
                }

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <T, CMPStorageError> > FetchAsync <T>(string tableNameString, string partitionKeyString,
                                                                       string rowKeyString,
                                                                       CMPTableStorageOptions tableStorageOptions = null)
            where T : CMPTableStorageModel, new()
        {
            if (_cloudTableClient == null)
            {
                return(new Tuple <T, CMPStorageError>(null, null));
            }

            if (string.IsNullOrEmpty(tableNameString) == true)
            {
                return(new Tuple <T, CMPStorageError>(null, null));
            }

            try
            {
                var tableReference = _cloudTableClient.GetTableReference(tableNameString);
                if (tableReference == null)
                {
                    return(new Tuple <T, CMPStorageError>(null, null));
                }

                var tableOperation = TableOperation.Retrieve <T>(partitionKeyString, rowKeyString);

                TableResult fetchedResultInfo = null;
                if (tableStorageOptions == null)
                {
                    fetchedResultInfo = await tableReference.ExecuteAsync(tableOperation);
                }
                else
                {
                    fetchedResultInfo = await tableReference.ExecuteAsync(tableOperation,
                                                                          tableStorageOptions.TableRequestOptions,
                                                                          tableStorageOptions.OperationContext,
                                                                          _tokenSource.Token);
                }

                return(new Tuple <T, CMPStorageError>(fetchedResultInfo.Result as T, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <T, CMPStorageError>(null, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > DeleteBatchMessagesAsync(List <CloudQueueMessage>
                                                                                    queueMessagesList,
                                                                                    CMPQueueStorageOptions
                                                                                    queueStorageOptions = null)
        {
            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                await Task.Run(() =>
                {
                    var deleteTasksArray = queueMessagesList.Select(async(CloudQueueMessage queueMessageInfo) =>
                    {
                        if (queueMessageInfo == null)
                        {
                            return;
                        }

                        await DeleteMessageAsync(queueMessageInfo, queueStorageOptions);
                    }).ToArray();

                    Task.WaitAll(deleteTasksArray, _tokenSource.Token);
                });

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (OperationCanceledException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > DeQueueMessageAsync(TimeSpan visibilityTimeOut,
                                                                               CMPQueueStorageOptions
                                                                               queueStorageOptions = null)
        {
            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                CloudQueueMessage queueMessage = null;
                if (queueStorageOptions == null)
                {
                    queueMessage = await _queueReference.GetMessageAsync();
                }
                else
                {
                    queueMessage = await _queueReference.GetMessageAsync(visibilityTimeOut,
                                                                         queueStorageOptions.QueueRequestOptions,
                                                                         queueStorageOptions.OperationContext,
                                                                         _tokenSource.Token);
                }

                ProcessQueueMessage?.Invoke(queueMessage);
                var couldDeleteInfo = await DeleteMessageAsync(queueMessage, queueStorageOptions);

                return(couldDeleteInfo);
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (OperationCanceledException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <byte[], CMPStorageError> > DownloadFromBlobAsync(string blobNameString,
                                                                                   CMPBlobStorageOptions
                                                                                   blobStorageOptions = null)
        {
            if (string.IsNullOrEmpty(blobNameString) == true)
            {
                return(new Tuple <byte[], CMPStorageError>(null, null));
            }

            try
            {
                var blobReference = PrepareBlockBlobReference(blobNameString);
                if (blobReference == null)
                {
                    return(new Tuple <byte[], CMPStorageError>(null, null));
                }

                var memoryStream = new MemoryStream();
                if (blobStorageOptions == null)
                {
                    await blobReference.DownloadToStreamAsync(memoryStream);
                }
                else
                {
                    await blobReference.DownloadToStreamAsync(memoryStream, blobStorageOptions.AccessCondition,
                                                              blobStorageOptions.BlobRequestOptions,
                                                              blobStorageOptions.OperationContext, _tokenSource.Token);
                }

                memoryStream.Close();
                var downloadedBytesArray = memoryStream.GetBuffer();
                return(new Tuple <byte[], CMPStorageError>(downloadedBytesArray, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <byte[], CMPStorageError>(null, null));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <byte[], CMPStorageError>(null, null));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > DeleteBlobAsync(string blobNameString,
                                                                           CMPBlobStorageOptions
                                                                           blobStorageOptions = null)
        {
            if (string.IsNullOrEmpty(blobNameString) == true)
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            try
            {
                var blobReference = PrepareBlockBlobReference(blobNameString);
                if (blobReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                var couldDelete = false;
                if (blobStorageOptions == null)
                {
                    couldDelete = await blobReference.DeleteIfExistsAsync();
                }
                else
                {
                    couldDelete = await blobReference.DeleteIfExistsAsync(blobStorageOptions.DeleteSnapshotsOption,
                                                                          blobStorageOptions.AccessCondition,
                                                                          blobStorageOptions.BlobRequestOptions,
                                                                          blobStorageOptions.OperationContext,
                                                                          _tokenSource.Token);
                }

                return(new Tuple <bool, CMPStorageError>(couldDelete, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > AddBytesToBlobAsync(byte[] blobBytesArray,
                                                                               string blobNameString,
                                                                               CMPBlobStorageOptions
                                                                               blobStorageOptions = null)
        {
            if ((blobBytesArray == null) || (blobBytesArray.Length == 0))
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            try
            {
                var blobReference = PrepareBlockBlobReference(blobNameString);
                if (blobReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                if (blobStorageOptions == null)
                {
                    await blobReference.UploadFromByteArrayAsync(blobBytesArray, 0, blobBytesArray.Length);
                }
                else
                {
                    await blobReference.UploadFromByteArrayAsync(blobBytesArray, 0, blobBytesArray.Length,
                                                                 blobStorageOptions.AccessCondition,
                                                                 blobStorageOptions.BlobRequestOptions,
                                                                 blobStorageOptions.OperationContext,
                                                                 _tokenSource.Token);
                }

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > DeleteMessageAsync(string deleteMessageString,
                                                                              string popupTokenString,
                                                                              CMPQueueStorageOptions
                                                                              queueStorageOptions = null)
        {
            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                var cloudMessage = await _queueReference.GetMessageAsync();

                if (queueStorageOptions == null)
                {
                    await _queueReference.DeleteMessageAsync(deleteMessageString, popupTokenString);
                }
                else
                {
                    await _queueReference.DeleteMessageAsync(deleteMessageString, popupTokenString,
                                                             queueStorageOptions.QueueRequestOptions,
                                                             queueStorageOptions.OperationContext, _tokenSource.Token);
                }

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
            catch (OperationCanceledException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <string, string, CMPStorageError> > PeekMessageAsync(CMPQueueStorageOptions
                                                                                      queueStorageOptions = null)
        {
            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <string, string, CMPStorageError>(null, null, null));
                }

                CloudQueueMessage queueMessage = null;
                if (queueStorageOptions == null)
                {
                    await _queueReference.PeekMessageAsync();
                }
                else
                {
                    await _queueReference.PeekMessageAsync(queueStorageOptions.QueueRequestOptions,
                                                           queueStorageOptions.OperationContext, _tokenSource.Token);
                }

                return(new Tuple <string, string, CMPStorageError>(queueMessage.AsString, queueMessage.PopReceipt,
                                                                   null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <string, string, CMPStorageError>(null, null, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <string, string, CMPStorageError>(null, null, error));
            }
            catch (OperationCanceledException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <string, string, CMPStorageError>(null, null, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > CreateBlobContainerAsync(CMPBlobStorageOptions
                                                                                    blobStorageOptions = null)
        {
            if (string.IsNullOrEmpty(_containerNameString) == true)
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            try
            {
                var blobContainerReference = _cloudBlobClient.GetContainerReference(_containerNameString);
                if (blobContainerReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                var couldCreate = false;
                if (blobStorageOptions == null)
                {
                    couldCreate = await blobContainerReference.CreateIfNotExistsAsync();
                }
                else
                {
                    couldCreate = await blobContainerReference.CreateIfNotExistsAsync(blobStorageOptions.
                                                                                      BlobContainerPublicAccessType,
                                                                                      blobStorageOptions.
                                                                                      BlobRequestOptions,
                                                                                      blobStorageOptions.
                                                                                      OperationContext,
                                                                                      _tokenSource.Token);
                }
                return(new Tuple <bool, CMPStorageError>(couldCreate, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <List <T>, CMPStorageError> > FetchAsync <T>(string tableNameString,
                                                                              string partitionKeyString,
                                                                              FetchProgressCallback <T> fetchProgressCallback)
            where T : CMPTableStorageModel, new()
        {
            if (_cloudTableClient == null)
            {
                return(new Tuple <List <T>, CMPStorageError>(null, null));
            }

            if (string.IsNullOrEmpty(tableNameString) == true)
            {
                return(new Tuple <List <T>, CMPStorageError>(null, null));
            }

            try
            {
                var tableReference = _cloudTableClient.GetTableReference(tableNameString);
                if (tableReference == null)
                {
                    return(new Tuple <List <T>, CMPStorageError>(null, null));
                }

                string filterConditionString = TableQuery.GenerateFilterCondition(KPartitionKeystring,
                                                                                  QueryComparisons.Equal,
                                                                                  partitionKeyString);

                var fetchedResultsInfo = await FetchForFilterAsync <T>(tableReference, filterConditionString,
                                                                       fetchProgressCallback);

                return(fetchedResultsInfo);
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <List <T>, CMPStorageError>(null, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > CreateTableAsync(string tableNameString,
                                                                            CMPTableStorageOptions tableStorageOptions =
                                                                            null)
        {
            if (_cloudTableClient == null)
            {
                return(new Tuple <bool, CMPStorageError>(false, null));
            }

            try
            {
                var tableReference = _cloudTableClient.GetTableReference(tableNameString);
                if (tableReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                var couldCreate = false;
                if (tableStorageOptions == null)
                {
                    couldCreate = await tableReference.CreateIfNotExistsAsync();
                }
                else
                {
                    couldCreate = await tableReference.CreateIfNotExistsAsync(tableStorageOptions.TableRequestOptions,
                                                                              tableStorageOptions.OperationContext,
                                                                              _tokenSource.Token);
                }

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, error));
            }
        }
        public async Task <Tuple <T, CMPStorageError> > DeleteRowAsync <T>(string tableNameString, T deleteModel,
                                                                           CMPTableStorageOptions tableStorageOptions =
                                                                           null)
            where T : CMPTableStorageModel, new()
        {
            if (_cloudTableClient == null)
            {
                return(new Tuple <T, CMPStorageError>(null, null));
            }

            if (string.IsNullOrEmpty(tableNameString) == true)
            {
                return(new Tuple <T, CMPStorageError>(null, null));
            }

            if (deleteModel == null)
            {
                return(new Tuple <T, CMPStorageError>(null, null));
            }

            try
            {
                var tableReference = _cloudTableClient.GetTableReference(tableNameString);
                if (tableReference == null)
                {
                    return(new Tuple <T, CMPStorageError>(null, null));
                }

                var retrieveOperation = TableOperation.Retrieve <T>(deleteModel.PartitionKey, deleteModel.RowKey);
                var retrieveResult    = await tableReference.ExecuteAsync(retrieveOperation);

                var retrievedModel = retrieveResult?.Result as T;
                if (retrievedModel == null)
                {
                    return(new Tuple <T, CMPStorageError>(null, null));
                }

                var deleteOperation = TableOperation.Delete(retrievedModel);

                TableResult deleteResult = null;
                if (tableStorageOptions == null)
                {
                    deleteResult = await tableReference.ExecuteAsync(deleteOperation);
                }
                else
                {
                    deleteResult = await tableReference.ExecuteAsync(deleteOperation,
                                                                     tableStorageOptions.TableRequestOptions,
                                                                     tableStorageOptions.OperationContext,
                                                                     _tokenSource.Token);
                }

                return(new Tuple <T, CMPStorageError>(deleteResult?.Result as T, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <T, CMPStorageError>(null, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <T, CMPStorageError>(null, error));
            }
        }
        public async Task <List <Tuple <T, CMPStorageError> > > DeleteRowsAsync <T>(string tableNameString,
                                                                                    string partitionKeyString,
                                                                                    CMPTableStorageOptions
                                                                                    tableStorageOptions = null)
            where T : CMPTableStorageModel, new()
        {
            if (_cloudTableClient == null)
            {
                return(null);
            }

            if (string.IsNullOrEmpty(tableNameString) == true)
            {
                return(null);
            }

            try
            {
                var tableReference = _cloudTableClient.GetTableReference(tableNameString);
                if (tableReference == null)
                {
                    return(null);
                }

                string filterConditionString = TableQuery.GenerateFilterCondition(KPartitionKeystring,
                                                                                  QueryComparisons.Equal,
                                                                                  partitionKeyString);

                var fetchedResultsInfo = await FetchForFilterAsync <T>(tableReference, filterConditionString);

                var fetchedResultsList = fetchedResultsInfo.Item1;

                if ((fetchedResultsList == null) || (fetchedResultsList.Count == 0))
                {
                    return(null);
                }

                var deleteResultsInfoList = new List <Tuple <T, CMPStorageError> >();
                var deleteTasksArray      = fetchedResultsList.Select(async(T deleteModel) =>
                {
                    var deleteResultInfo = await DeleteRowAsync <T>(tableNameString, deleteModel, tableStorageOptions);
                    deleteResultsInfoList.Add(deleteResultInfo);
                }).ToArray();

                await Task.WhenAll(deleteTasksArray);

                return(deleteResultsInfoList);
            }
            catch (StorageException exception)
            {
                var error     = CMPStorageError.CreateErrorFromException(exception);
                var errorInfo = new Tuple <T, CMPStorageError>(null, error);
                return(new List <Tuple <T, CMPStorageError> >()
                {
                    errorInfo
                });
            }
            catch (ArgumentException exception)
            {
                var error     = CMPStorageError.CreateErrorFromException(exception);
                var errorInfo = new Tuple <T, CMPStorageError>(null, error);
                return(new List <Tuple <T, CMPStorageError> >()
                {
                    errorInfo
                });
            }
        }
        public async Task <Tuple <List <T>, CMPStorageError> > InsertRowsInBatchAsync <T>(List <T> insertModelsList,
                                                                                          string tableNameString,
                                                                                          CMPTableStorageOptions
                                                                                          tableStorageOptions = null)
            where T : CMPTableStorageModel, new()

        {
            if (_cloudTableClient == null)
            {
                return(new Tuple <List <T>, CMPStorageError>(null, null));
            }

            if (string.IsNullOrEmpty(tableNameString) == true)
            {
                return(new Tuple <List <T>, CMPStorageError>(null, null));
            }

            if ((insertModelsList == null) || (insertModelsList.Count == 0) || (_cloudTableClient == null))
            {
                return(new Tuple <List <T>, CMPStorageError>(null, null));
            }

            try
            {
                var tableReference = _cloudTableClient.GetTableReference(tableNameString);
                if (tableReference == null)
                {
                    return(new Tuple <List <T>, CMPStorageError>(null, null));
                }

                var insertInBatchOperation = new TableBatchOperation();
                foreach (var insertModel in insertModelsList)
                {
                    insertInBatchOperation.Insert(insertModel);
                }

                IList <TableResult> insertInBatchResult = null;
                if (tableStorageOptions == null)
                {
                    insertInBatchResult = await tableReference.ExecuteBatchAsync(insertInBatchOperation);
                }
                else
                {
                    insertInBatchResult = await tableReference.ExecuteBatchAsync(insertInBatchOperation,
                                                                                 tableStorageOptions.TableRequestOptions,
                                                                                 tableStorageOptions.OperationContext,
                                                                                 _tokenSource.Token);
                }

                var insertResultsList = insertInBatchResult.Select((TableResult insertResult) =>
                {
                    return(insertResult?.Result as T);
                }).ToList();

                return(new Tuple <List <T>, CMPStorageError>(insertResultsList, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <List <T>, CMPStorageError>(null, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <List <T>, CMPStorageError>(null, error));
            }
        }
        public async Task <Tuple <bool, CMPStorageError> > DeQueueBatchMessagesAsync(TimeSpan visibilityTimeOut,
                                                                                     int deQueueCount,
                                                                                     CMPQueueStorageOptions
                                                                                     queueStorageOptions = null)
        {
            try
            {
                if (_queueReference == null)
                {
                    return(new Tuple <bool, CMPStorageError>(false, null));
                }

                if (deQueueCount == 0)
                {
                    deQueueCount = await GetMessagesCountAsync(queueStorageOptions);
                }

                int batchCount = (deQueueCount / 10);
                if (batchCount == 0)
                {
                    batchCount = deQueueCount;
                }

                do
                {
                    IEnumerable <CloudQueueMessage> queueMessages = null;
                    if (queueStorageOptions == null)
                    {
                        queueMessages = await _queueReference.GetMessagesAsync(batchCount);
                    }
                    else
                    {
                        queueMessages = await _queueReference.GetMessagesAsync(batchCount, visibilityTimeOut,
                                                                               queueStorageOptions.QueueRequestOptions,
                                                                               queueStorageOptions.OperationContext,
                                                                               _tokenSource.Token);
                    }

                    var queueMessagesList = queueMessages.ToList();
                    ProcessQueueBatchMessages?.Invoke(queueMessagesList);
                    await DeleteBatchMessagesAsync(queueMessagesList, queueStorageOptions);
                } while ((deQueueCount -= batchCount) > 0);

                return(new Tuple <bool, CMPStorageError>(true, null));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, null));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, null));
            }
            catch (OperationCanceledException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <bool, CMPStorageError>(false, null));
            }
        }
        public async Task <Tuple <T, CMPStorageError> > InsertRowAsync <T>(T insertModel, string tableNameString,
                                                                           CMPTableStorageOptions tableStorageOptions =
                                                                           null)
            where T : CMPTableStorageModel, new()
        {
            if (_cloudTableClient == null)
            {
                return(new Tuple <T, CMPStorageError>(null, null));
            }

            if (string.IsNullOrEmpty(tableNameString) == true)
            {
                return(new Tuple <T, CMPStorageError>(null, null));
            }

            if ((insertModel == null) || (_cloudTableClient == null))
            {
                return(new Tuple <T, CMPStorageError>(null, null));
            }

            try
            {
                var tableReference = _cloudTableClient.GetTableReference(tableNameString);
                if (tableReference == null)
                {
                    return(new Tuple <T, CMPStorageError>(null, null));
                }

                var         insertOperation = TableOperation.Insert(insertModel);
                TableResult insertResult    = null;

                if (tableStorageOptions == null)
                {
                    insertResult = await tableReference.ExecuteAsync(insertOperation);
                }
                else
                {
                    insertResult = await tableReference.ExecuteAsync(insertOperation,
                                                                     tableStorageOptions.TableRequestOptions,
                                                                     tableStorageOptions.OperationContext,
                                                                     _tokenSource.Token);
                }

                CMPStorageError error = null;
                if (insertResult.HttpStatusCode != 200)
                {
                    error = CMPStorageError.CreateError(insertResult.HttpStatusCode.ToString(), string.Empty);
                }

                return(new Tuple <T, CMPStorageError>(insertResult.Result as T,
                                                      error));
            }
            catch (StorageException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <T, CMPStorageError>(null, error));
            }
            catch (ArgumentException exception)
            {
                var error = CMPStorageError.CreateErrorFromException(exception);
                return(new Tuple <T, CMPStorageError>(null, error));
            }
        }