public TableQuerySegment<EventEntity> GetEvents(TableContinuationToken token, EventFilter filter)
        {
            var list = (from events in table.CreateQuery<EventEntity>()
                       where events.alerttype.Equals(filter.type) select events
               );

            TableQuery<EventEntity> query = new TableQuery<EventEntity>().Where(filter.GetFilterString()).Take(100);
            TableQuerySegment<EventEntity> resultSegment = table.ExecuteQuerySegmented(query, token);

            return resultSegment;
        }

 public string SerializeToken(TableContinuationToken tableContinuationToken)
 {
     if (tableContinuationToken == null) return string.Empty;
     var serialized = JsonConvert.SerializeObject(tableContinuationToken);
     var bytes = Encoding.UTF8.GetBytes(serialized);
     return Convert.ToBase64String(bytes);
 }

        public TableQuerySegment<EventEntity> GetAllEvents(TableContinuationToken token)
        {
            TableQuery<EventEntity> query = new TableQuery<EventEntity>().Take(100);
            TableQuerySegment<EventEntity> resultSegment = table.ExecuteQuerySegmented(query, token);

            return resultSegment;
        }

        private static RESTCommand<TableQuerySegment> QueryImpl(TableQuery query, TableContinuationToken token, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
        {
            UriQueryBuilder builder = query.GenerateQueryBuilder();

            if (token != null)
            {
                token.ApplyToUriQueryBuilder(builder);
            }

            StorageUri tempUriList = NavigationHelper.AppendPathToUri(client.StorageUri, tableName);
            RESTCommand<TableQuerySegment> queryCmd = new RESTCommand<TableQuerySegment>(client.Credentials, tempUriList);
            requestOptions.ApplyToStorageCommand(queryCmd);

            queryCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(token);
            queryCmd.RetrieveResponseStream = true;
            queryCmd.Handler = client.AuthenticationHandler;
            queryCmd.BuildClient = HttpClientFactory.BuildHttpClient;
            queryCmd.Builder = builder;
            queryCmd.BuildRequest = (cmd, uri, queryBuilder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableQuery(uri, builder, serverTimeout, cnt, ctx);
            queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp.StatusCode, null /* retVal */, cmd, ex);
            queryCmd.PostProcessResponse = async (cmd, resp, ctx) =>
            {
                TableQuerySegment resSeg = await TableOperationHttpResponseParsers.TableQueryPostProcess(cmd.ResponseStream, resp, ctx);
                if (resSeg.ContinuationToken != null)
                {
                    resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation;
                }

                return resSeg;
            };

            return queryCmd;
        }

        internal TableQuerySegment<DynamicTableEntity> ExecuteQuerySegmented(TableContinuationToken token, CloudTableClient client, string tableName, TableRequestOptions requestOptions, OperationContext operationContext)
        {
            CommonUtils.AssertNotNullOrEmpty("tableName", tableName);
            TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client);
            operationContext = operationContext ?? new OperationContext();

            RESTCommand<TableQuerySegment<DynamicTableEntity>> cmdToExecute = QueryImpl(this, token, client, tableName, modifiedOptions);

            return Executor.ExecuteSync(cmdToExecute, modifiedOptions.RetryPolicy, operationContext);
        }

 public string Serialize(TableContinuationToken continuationToken)
 {
     if (continuationToken == null) return null;
     StringBuilder sb = new StringBuilder();
     using (XmlWriter xmlWriter = XmlWriter.Create(new StringWriter(sb)))
     {
         continuationToken.WriteXml(xmlWriter);
     }
     return sb.ToString();
 }

        public string Serialize(TableContinuationToken continuationToken)
        {
            if (continuationToken == null) return null;

            using (StringWriter stringWriter = new StringWriter())
            {
                using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter))
                {
                    continuationToken.WriteXml(xmlWriter);
                }
                return stringWriter.ToString();
            }
        }

        internal ICancellableAsyncResult BeginExecuteQuerySegmented(TableContinuationToken token, CloudTableClient client, string tableName, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
        {
            CommonUtils.AssertNotNullOrEmpty("tableName", tableName);

            TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client);
            operationContext = operationContext ?? new OperationContext();

            return Executor.BeginExecuteAsync(
                                          QueryImpl(this, token, client, tableName, modifiedOptions),
                                          modifiedOptions.RetryPolicy,
                                          operationContext,
                                          callback,
                                          state);
        }

        internal IAsyncOperation<TableQuerySegment> ExecuteQuerySegmentedAsync(TableContinuationToken continuationToken, CloudTableClient client, string tableName, TableRequestOptions requestOptions, OperationContext operationContext)
        {
            CommonUtility.AssertNotNullOrEmpty("tableName", tableName);
            TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client);
            operationContext = operationContext ?? new OperationContext();

            RESTCommand<TableQuerySegment> cmdToExecute = QueryImpl(this, continuationToken, client, tableName, modifiedOptions);

            return AsyncInfo.Run(async (cancellationToken) => await Executor.ExecuteAsync(
                                                                                       cmdToExecute,
                                                                                       modifiedOptions.RetryPolicy,
                                                                                       operationContext,
                                                                                       cancellationToken));
        }

 public async Task<TableQuerySegment<DynamicTableEntity>> GetTableDataByDate(string tableName, string filter, DateTime from, DateTime to, TableContinuationToken continuationToken, bool hasLeadingZero)
 {
     var fromUtc = from.ToUniversalTime();
     var toUtc = to.ToUniversalTime();
     var lead = hasLeadingZero ? "0" : "";
     string fromFilter = TableQuery.GenerateFilterCondition("PartitionKey",
         QueryComparisons.GreaterThanOrEqual, string.Format("{0}{1}", lead, fromUtc.Ticks));
     string toFilter = TableQuery.GenerateFilterCondition("PartitionKey",
         QueryComparisons.LessThan, string.Format("{0}{1}", lead, toUtc.Ticks));
     var filterQuery = TableQuery.CombineFilters(toFilter, TableOperators.And, fromFilter);
     if (!String.IsNullOrEmpty(filter))
     {
         filterQuery = TableQuery.CombineFilters(filter, TableOperators.And, filterQuery);
     }
     return await GetData(tableName, filterQuery, continuationToken);
 }

        protected CloudTableSegmentedQuery(
            int? take,
            string[] properties,
            Func<TableQuery<DynamicTableEntity>, TableContinuationToken, Task<TableQuerySegment<DynamicTableEntity>>> fetchEntities,
            ITableEntityConverter tableEntityConverter)
        {
            Require.True(!take.HasValue || take > 0, "take", "Value should contains positive value");
            Require.NotNull(properties, "properties");
            Require.NotNull(fetchEntities, "fetchEntities");
            Require.NotNull(tableEntityConverter, "tableEntityConverter");

            m_take = take;
            m_properties = properties;
            m_fetchEntities = fetchEntities;
            m_tableEntityConverter = tableEntityConverter;
            m_continuationToken = null;
        }

      public static void ClassCleanup()
      {
         var storageAccountProvider = Configuration.GetTestStorageAccount();

         var client = new CloudTableClient( new Uri( storageAccountProvider.TableEndpoint ), storageAccountProvider.Credentials );

         TableContinuationToken token = new TableContinuationToken();
         do
         {
            var orphanedTables = client.ListTablesSegmentedAsync( _baseTableName, token ).Result;
            token = orphanedTables.ContinuationToken;
            foreach ( CloudTable orphanedTableName in orphanedTables.Results )
            {
               client.GetTableReference( orphanedTableName.Name ).DeleteIfExistsAsync().Wait();
            }
         }
         while ( token != null );
      }

        /// <summary>
        ///     Returns an enumerable collection of tables in the storage account asynchronously.
        /// </summary>
        /// <param name="tableClient">Cloud table client.</param>
        /// <param name="prefix">The table name prefix.</param>
        /// <param name="maxResults">
        ///     A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the
        ///     per-operation limit of 5000. If this value is zero the maximum possible number of results will be returned, up to 5000.
        /// </param>
        /// <param name="continuationToken">Continuation token.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        /// <returns>
        ///     An enumerable collection of tables that are retrieved lazily.
        /// </returns>
        public static Task<TableResultSegment> ListTablesSegmentedAsync(
            this CloudTableClient tableClient,
            string prefix,
            int? maxResults,
            TableContinuationToken continuationToken,
            CancellationToken cancellationToken = default (CancellationToken))
        {
            ICancellableAsyncResult asyncResult = tableClient.BeginListTablesSegmented(prefix, maxResults, continuationToken, null, null, null, null);
            CancellationTokenRegistration registration = cancellationToken.Register(p => asyncResult.Cancel(), null);

            return Task<TableResultSegment>.Factory.FromAsync(
                asyncResult,
                result =>
                    {
                        registration.Dispose();
                        return tableClient.EndListTablesSegmented(result);
                    });
        }

        public static TableContinuationToken DeserializeToken(string token)
        {
            if (!string.IsNullOrWhiteSpace(token))
            {
                var raw = DecodeBase64(token);
                TableContinuationToken contToken = null;

                using (var stringReader = new StringReader(raw))
                {
                    contToken = new TableContinuationToken();
                    using (var xmlReader = XmlReader.Create(stringReader))
                    {
                        contToken.ReadXml(xmlReader);
                    }
                }
                return contToken;
            }
            return null;            
        }

 public TableQuerySegment<TweetTableEntity> Get1000Tweets(ref TableContinuationToken token)
 {
     var query = new TableQuery();
     EntityResolver<TweetTableEntity> tweetTableEntityResolver = (pk, rk, ts, props, etag) =>
     {
         var resolvedEntity = new TweetTableEntity
         {
             PartitionKey = pk,
             RowKey = rk,
             Timestamp = ts,
             ETag = etag,
         };
         resolvedEntity.ReadEntity(props, null);
         return resolvedEntity;
     };
     var segment = _tweetsTable.ExecuteQuerySegmented(query, tweetTableEntityResolver, token);
     token = segment.ContinuationToken;
     return segment;
 }

        public static string SerializeToken(TableContinuationToken token)
        {
            if (token == null)
            {
                return null;
            }

            using (var writer = new StringWriter(CultureInfo.InvariantCulture))
            {
                using (var xmlWriter = XmlWriter.Create(writer))
                {
                    token.WriteXml(xmlWriter);
                }
                string serialized = writer.ToString();
                var val = EncodeBase64(serialized);
                return val;
            }

           
        }

        private async Task<TableQuerySegment<DynamicTableEntity>> GetData(string tableName, string filter, TableContinuationToken continuationToken)
        {
            var table = tableClient.GetTableReference(tableName);
            if (!table.Exists())
            {
                throw new ArgumentException("Table does not exist", tableName);
            }

            var query = new TableQuery<DynamicTableEntity>();
            if (!String.IsNullOrEmpty(filter))
            {
                query = query.Where(filter);
            }

            if (continuationToken != null)
            {
                continuationToken.NextTableName = tableName;
            }
            return await table.ExecuteQuerySegmentedAsync(query, continuationToken);
        }

        public HttpResponseMessage Get([FromUri]EventFilter filter, string NextPartitionKey = null, string NextRowKey = null)
        {
            TableContinuationToken token = null;
            if (!String.IsNullOrEmpty(NextPartitionKey) && !String.IsNullOrEmpty(NextRowKey))
            {
                token = new TableContinuationToken();
                token.NextRowKey = NextRowKey;
                token.NextPartitionKey = NextPartitionKey;
                token.TargetLocation = Microsoft.WindowsAzure.Storage.StorageLocation.Primary;
            }
            var values = dataConnector.GetEvents(token,filter);
            var response = Request.CreateResponse(HttpStatusCode.OK, values);

            //add continuation token to header
            if (values.ContinuationToken != null && !String.IsNullOrEmpty(values.ContinuationToken.NextPartitionKey) && !String.IsNullOrEmpty(values.ContinuationToken.NextRowKey))
            {
                response.Headers.Add("x-ms-continuation-NextPartitionKey", values.ContinuationToken.NextPartitionKey);
                response.Headers.Add("x-ms-continuation-NextRowKey", values.ContinuationToken.NextRowKey);

            }
            return response;
        }

        public ActionResult List(string pk, string rk)
        {
            var storageAccount = CloudStorageAccount.Parse(_storageConnection);

            var tableClient = storageAccount.CreateCloudTableClient();

            var table = tableClient.GetTableReference("SlabLogsTable");

            if (!table.Exists())
                return HttpNotFound();

            var query = (from ent in table.CreateQuery<SlabLogsTable>()
                         select ent)
                         .Take(100)
                         .AsTableQuery();

            TableContinuationToken token = null;

            if (!string.IsNullOrEmpty(pk) && !string.IsNullOrEmpty(rk))
                token = new TableContinuationToken() { NextPartitionKey = pk, NextRowKey = rk };

            var queryResult = query.ExecuteSegmented(token);

            var results = queryResult
                            .ToList()
                            .OrderByDescending(i => i.EventDate); // added to handle issue when rowkey not deterministic across apps

            if (queryResult.ContinuationToken != null)
            {
                ViewBag.HasNextPage = true;
                ViewBag.NextPartitionKey = queryResult.ContinuationToken.NextPartitionKey;
                ViewBag.NextRowKey = queryResult.ContinuationToken.NextRowKey;
            }
            else
                ViewBag.HasNextPage = false;

            return View(results);
        }

        private static RESTCommand<TableQuerySegment> QueryImpl(TableQuery query, TableContinuationToken token, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
        {
            Uri tempUri = NavigationHelper.AppendPathToUri(client.BaseUri, tableName);
            UriQueryBuilder builder = query.GenerateQueryBuilder();

            if (token != null)
            {
                token.ApplyToUriQueryBuilder(builder);
            }

            Uri reqUri = builder.AddToUri(tempUri);

            RESTCommand<TableQuerySegment> queryCmd = new RESTCommand<TableQuerySegment>(client.Credentials, reqUri);
            queryCmd.ApplyRequestOptions(requestOptions);

            queryCmd.RetrieveResponseStream = true;
            queryCmd.Handler = client.AuthenticationHandler;
            queryCmd.BuildClient = HttpClientFactory.BuildHttpClient;
            queryCmd.BuildRequest = (cmd, cnt, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableQuery(cmd.Uri, cmd.ServerTimeoutInSeconds, ctx);
            queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp.StatusCode, null /* retVal */, cmd, ex);
            queryCmd.PostProcessResponse = (cmd, resp, ctx) => TableOperationHttpResponseParsers.TableQueryPostProcess(cmd.ResponseStream, resp, ctx);

            return queryCmd;
        }