public Tracker(string accountName, string keyValue) { _applicationId = IdUtil.ApplicationId(); _deviceId = IdUtil.DeviceId(); _anid = IdUtil.GetAnidFromOs(); _appTitle = IdUtil.ApplicationName(); _adsRefreshRate = 3; _pubCenterAdsId = new List<string>(); _adsReady = false; // Due to Disallowed key in RowKey, /, \, #, ? needs to be removed // And excel cannot allow "=" at the beginning foreach (var s in _invalidRowKeyChar) { _deviceId = _deviceId.Replace(s, string.Empty); if (_deviceId.Substring(0, 1) == "=") { _deviceId = "x" + _deviceId; } } GetAdAssemblyVersion(); RefreshIpInfo(); _storageCredentials = new StorageCredentials(accountName, keyValue); _storageAccount = new CloudStorageAccount(_storageCredentials, false); _tableClient = _storageAccount.CreateCloudTableClient(); EnsureTablesCreated(); }
public TestCacheStats(TestResultStorage testResultStorage, CloudTableClient tableClient) { _testResultStorage = testResultStorage; _unitTestCounterUtil = new CounterUtil<UnitTestCounterEntity>(tableClient.GetTableReference(AzureConstants.TableNames.CounterUnitTestQuery)); _testCacheCounterUtil = new CounterUtil<TestCacheCounterEntity>(tableClient.GetTableReference(AzureConstants.TableNames.CounterTestCache)); _testRunCounterUtil = new CounterUtil<TestRunCounterEntity>(tableClient.GetTableReference(AzureConstants.TableNames.CounterTestRun)); }
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; }
private void CleanupTable(string tableName) { var account = CloudStorageAccount.DevelopmentStorageAccount; var cloudTableClient = new CloudTableClient(account.TableEndpoint, account.Credentials); var table = cloudTableClient.GetTableReference(tableName); table.DeleteIfExists(); }
protected CloudCoreStoredTable(string accountSonnectionString = "") { SetAccount(accountSonnectionString); cloudTableClient = cloudStorageAccount.CreateCloudTableClient(); cloudTable = cloudTableClient.GetTableReference(GetType().Name.Replace("Entity", "").Replace("Table", "").ToLower()); cloudTable.CreateIfNotExists(); }
public HomeController() { storageAccount = CloudStorageAccount.Parse( ConfigurationManager.AppSettings["StorageConnectionString"]); tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("fouramigos"); table.CreateIfNotExists(); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference("fouramigos"); container.CreateIfNotExists(); BlobContainerPermissions permissions = container.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(permissions); //lägga till nya //var tablemodels = new TableModel("Brutus", "Uggla") { Location = "T4", Description="Uggla i träd", Type="Foto" }; //var tablemodels1 = new TableModel("brutus", "Örn") { Location = "T4", Description="Örn som flyger", Type = "Foto" }; //var opreation = TableOperation.Insert(tablemodels); //var operation2 = TableOperation.Insert(tablemodels1); //table.Execute(opreation); //table.Execute(operation2); }
public TProduct(string affiliate, string code, int qty, bool force_lookup = false) { ProductCode = code; Qty = qty; cloud = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("AbundaStorage")); client = cloud.CreateCloudTableClient(); products = client.GetTableReference("Products"); products.CreateIfNotExists(); using (var context = new DataBaseDataContext()) { var aff = (from ev in context.Affiliates where ev.code == affiliate select ev).FirstOrDefault(); merchantID = aff.MerchantID; marketplaceID = aff.MarketPlaceID; secretKey = aff.SecretKey; accessKey = aff.AccessKey; } var amzResults = PerformAmazonLookup(); }
public AzureTableStorageStatusTraceListener(String initializeData) : base(initializeData) { string connectionString = null; string tableName = "status"; if (initializeData != null) { foreach (String keyValuePair in initializeData.Split(',')) { String[] parts = keyValuePair.Split('*'); if (parts.Length == 2) { if (parts[0].Equals("tablestorage", StringComparison.InvariantCultureIgnoreCase)) { connectionString = parts[1].Trim(); } else if (parts[0].Equals("table", StringComparison.InvariantCultureIgnoreCase)) { tableName = parts[1].Trim(); } } } } if (String.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentNullException("tablestorage", "The initializeData string must specify the Azure table storage connection string in the tablestorage field."); } this._storageAccount = CloudStorageAccount.Parse(connectionString); this._tableClient = this._storageAccount.CreateCloudTableClient(); this._table = this._tableClient.GetTableReference(tableName); this._table.CreateIfNotExists(); }
static NDIAzureTableController() { _storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); _tableClient = _storageAccount.CreateCloudTableClient(); _table = _tableClient.GetTableReference("ndiparams"); _retrieveOperation = TableOperation.Retrieve("VidParams", "LastVideo"); }
public StorageTableAccessor(CloudStorageAccount storageAccount) { CloudTableClient tableClient = new CloudTableClient(storageAccount.TableStorageUri, storageAccount.Credentials); this.table = tableClient.GetTableReference(messageTableName); this.table.CreateIfNotExists(); ReadFirstEntry(); }
public AzureTableStorage(string connectionString, string tableName) { this._storageAccount = CloudStorageAccount.Parse(connectionString); this._tableClient = this._storageAccount.CreateCloudTableClient(); this._table = this._tableClient.GetTableReference(tableName); this._table.CreateIfNotExists(); }
public AuditAzureTableProvider() { try { _account = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["AzureStorageConnectionString"]); _client = _account.CreateCloudTableClient(); } catch (Exception exp) { throw new Exception("Error retreiving reference to Azure Storage Account", exp); } try { _client = _account.CreateCloudTableClient(); } catch (Exception exp) { throw new Exception("Error creating Azure Table Client Object", exp); } try { _vmAuditTable = _client.GetTableReference("VMAudits"); } catch (Exception exp) { throw new Exception("Error retreiving reference to Azure Table Object", exp); } }
private void Init() { Trace.TraceInformation("Starting initialization."); Account = CloudStorageAccount.Parse(ConfigurationManager.AppSettings[Constants.ConfigurationSectionKey]); TableClient = Account.CreateCloudTableClient(); Container = Account.CreateCloudBlobClient().GetContainerReference(Constants.ContainerName); BlobContainerPermissions blobPermissions = new BlobContainerPermissions(); blobPermissions.SharedAccessPolicies.Add(ConfigurationManager.AppSettings["AccountId"], new SharedAccessBlobPolicy() { SharedAccessExpiryTime = DateTime.UtcNow.AddHours(10), Permissions = SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.Read }); blobPermissions.PublicAccess = BlobContainerPublicAccessType.Off; // Set the permission policy on the container. Container.SetPermissions(blobPermissions); SasToken = Container.GetSharedAccessSignature(new SharedAccessBlobPolicy(), ConfigurationManager.AppSettings["AccountId"]); BlobBaseUri = Account.BlobEndpoint; Trace.TraceInformation("Initialization finished."); }
public BlobStorageManager(string blobConnectionEndPointString) { this.blobConnectionEndPointString = blobConnectionEndPointString; CloudStorageAccount VP2ClientBlobStorageAccount = CloudStorageAccount.Parse(blobConnectionEndPointString); VP2CloudBlobClient = VP2ClientBlobStorageAccount.CreateCloudBlobClient(); VP2CloudTableClient = VP2ClientBlobStorageAccount.CreateCloudTableClient(); }
public virtual void Initialize() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); tableClient = storageAccount.CreateCloudTableClient(); }
public SensorAccess() { credentials = new StorageCredentials(_accountName, _key); storageAccount = new CloudStorageAccount(credentials, true); tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("AccelerometerTable"); }
static void CreateCustomerMetadata(CloudTableClient tableClient) { Console.WriteLine("Creating customers metadata..."); CloudTable customersMetadataTable = tableClient.GetTableReference("customersmetadata"); customersMetadataTable.CreateIfNotExists(); var msftAddress1 = new DictionaryTableEntity(); msftAddress1.PartitionKey = "MSFT"; msftAddress1.RowKey = "ADDRESS-" + Guid.NewGuid().ToString("N").ToUpper(); msftAddress1.Add("city", "Seattle"); msftAddress1.Add("street", "111 South Jackson"); var msftWebsite1 = new DictionaryTableEntity(); msftWebsite1.PartitionKey = "MSFT"; msftWebsite1.RowKey = "WEBSITE-" + Guid.NewGuid().ToString("N").ToUpper(); msftWebsite1.Add("url", "http://www.microsoft.com"); var msftWebsite2 = new DictionaryTableEntity(); msftWebsite2.PartitionKey = "MSFT"; msftWebsite2.RowKey = "WEBSITE-" + Guid.NewGuid().ToString("N").ToUpper(); msftWebsite2.Add("url", "http://www.windowsazure.com"); var batch = new TableBatchOperation(); batch.Add(TableOperation.Insert(msftAddress1)); batch.Add(TableOperation.Insert(msftWebsite1)); batch.Add(TableOperation.Insert(msftWebsite2)); customersMetadataTable.ExecuteBatch(batch); Console.WriteLine("Done. Press ENTER to read the customer metadata."); Console.ReadLine(); }
public static CloudTableClient GenerateCloudTableClient() { Uri baseAddressUri = new Uri(TestBase.TargetTenantConfig.TableServiceEndpoint); CloudTableClient client = new CloudTableClient(baseAddressUri, TestBase.StorageCredentials); client.AuthenticationScheme = DefaultAuthenticationScheme; return client; }
private CloudTableClient GetCloudTableClient(string sasUrl) { int parseIndex = sasUrl.IndexOf('?'); if (parseIndex > 0) { string tableAddress = sasUrl.Substring(0, parseIndex); int tableParseIndex = tableAddress.LastIndexOf('/'); if (tableParseIndex > 0) { tableName = tableAddress.Substring(tableParseIndex + 1); string endpointAddress = tableAddress.Substring(0, tableParseIndex); string sasSignature = sasUrl.Substring(parseIndex); var tableClient = new CloudTableClient(new Uri(endpointAddress), new StorageCredentials(sasSignature)); // This is a hack for the Azure Storage SDK to make it work with version 2012 SAS urls as long as we support them. // Apply hack only if the SAS url is version 2012. if (sasSignature.IndexOf("sv=2012-02-12", StringComparison.OrdinalIgnoreCase) >= 0) { tableClient.DefaultRequestOptions.PayloadFormat = TablePayloadFormat.AtomPub; var type = typeof(TableConstants); var field = type.GetField("ODataProtocolVersion", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static); field.SetValue(null, ODataVersion.V2); } return tableClient; } } return null; }
private TableHelpers() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("forgeanalytics_AzureStorageConnectionString")); // Create the table client. client = storageAccount.CreateCloudTableClient(); }
public Mock<ICloudStorageServices> Build() { var cloudStorageServices = new Mock<ICloudStorageServices>(); var cloudTableClient = new CloudTableClient(new Uri("http://www.example.com/")); cloudStorageServices.SetupGet(x => x.CloudTableClient).Returns(cloudTableClient); return cloudStorageServices; }
public AzureEventStore(CloudStorageAccount account, string tableName) { this.account = account; this.client = account.CreateCloudTableClient(); this.tableName = tableName; this.created = false; }
internal TableResult Execute(CloudTableClient client, CloudTable table, TableRequestOptions requestOptions, OperationContext operationContext) { TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client); operationContext = operationContext ?? new OperationContext(); CommonUtility.AssertNotNullOrEmpty("tableName", table.Name); return Executor.ExecuteSync(this.GenerateCMDForOperation(client, table, modifiedOptions), modifiedOptions.RetryPolicy, operationContext); }
/// <summary> /// Initializes a new instance of the <see cref="CloudTable"/> class. /// </summary> /// <param name="tableName">The table name.</param> /// <param name="client">The client.</param> internal CloudTable(string tableName, CloudTableClient client) { CommonUtility.AssertNotNull("tableName", tableName); CommonUtility.AssertNotNull("client", client); this.Name = tableName; this.Uri = NavigationHelper.AppendPathToUri(client.BaseUri, tableName); this.ServiceClient = client; }
public TableStorageRegistry() { var storageConnectionString = ConfigurationHelper.GetConfigValue<string>("StorageConnectionString"); var storageClient = CloudStorageAccount.Parse(storageConnectionString); _client = storageClient.CreateCloudTableClient(); _table = _client.GetTableReference(TableName); _table.CreateIfNotExists(); }
public static void Initialize(string storageConnectionString) { // Get storage account _storageAccount = CloudStorageAccount.Parse(storageConnectionString); // Create the clients _tableClient = _storageAccount.CreateCloudTableClient(); }
private async Task StartAsync(CloudStorageAccount cloudStorageAccount, string tableName) { _cloudTableClient = cloudStorageAccount.CreateCloudTableClient(); _cloudTable = _cloudTableClient.GetTableReference(tableName); // create container if it does not exist on startup await _cloudTable.CreateIfNotExistAsync(); }
public TableHelper(string storageAccountConnectionString) : base(storageAccountConnectionString) { tableClient = base.StorageAccount.CreateCloudTableClient(); mailingListTable = tableClient.GetTableReference(ConfigurationManager.AppSettings["TableMailinglist"]); mailingListTable.CreateIfNotExists(); }
public AzureTableReplyChannel(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, AzureTableReplyChannelListener parent, CloudTableClient cloudTableClient, string tableName, string partitionKey, TimeSpan idleSleep, TimeSpan activeSleep) : base(bufferManager, encoderFactory, address, parent, parent.MaxReceivedMessageSize, cloudTableClient, tableName, partitionKey, idleSleep, activeSleep) { this.localAddress = address; }
public StreamstoneEventStoreInitializator(string storageAccountConnectionString) { if (string.IsNullOrWhiteSpace(storageAccountConnectionString)) throw new ArgumentNullException("storageAccountConnectionString"); var account = CloudStorageAccount.Parse(storageAccountConnectionString); tableClient = account.CreateCloudTableClient(); }
public async Task <JsonResult> GetExceptionLogChart(string SDate, string EDate) { string TotalSolved = String.Empty; string TotalUnSolved = String.Empty; string Dates = String.Empty; List <SolutionProvidedReportValues> IsSolvedRecordJson = new List <SolutionProvidedReportValues>(); List <SolutionResult> ResultRecordJson = new List <SolutionResult>(); try { string a = Convert.ToString(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the table client. Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Retrieve a reference to the table. // CloudTable table = tableClient.GetTableReference("SolutionProvidedReport"); table = tableClient.GetTableReference("ExceptionLog"); await table.CreateIfNotExistsAsync(); string StartdateString = SDate; //"2018-10-25T00:00:00.000Z"; string EnddateString = EDate; // "2018-11-10T00:00:00.000Z"; DateTime StartDate = DateTime.Parse(StartdateString, System.Globalization.CultureInfo.InvariantCulture); DateTime EndDate = DateTime.Parse(EnddateString, System.Globalization.CultureInfo.InvariantCulture); List <SolutionProvidedReport> SutdentListObj = RetrieveEntity <SolutionProvidedReport>(); var SutdentListObj1 = SutdentListObj.Where(item => item.Timestamp >= StartDate && item.Timestamp <= EndDate).OrderByDescending(item => item.Timestamp).GroupBy(item => item.Timestamp.Date).ToList(); foreach (var singleData in SutdentListObj1) { SolutionProvidedReportValues DataList = new SolutionProvidedReportValues(); SolutionResult resultdata = new SolutionResult(); DataList.Timestamp1 = (singleData.Key).ToString(); DataList.ExceptionLog = singleData.Count(); // resultdata.TotalNoRating += DataList.FailedTicket; //+ ", "; resultdata.ExceptionLogCount += DataList.ExceptionLog; // + ", "; resultdata.Dates += Convert.ToDateTime(DataList.Timestamp1).ToString("dd MMM"); // + ", "; ResultRecordJson.Add(resultdata); //IsSolvedRecordJson.Add(DataList); } } catch (Exception ex) { Utility.Utility.GenrateLog(ex.Message); } finally { } var output = JsonConvert.SerializeObject(ResultRecordJson); // var resultData = new {TotalSolved = TotalSolved, TotalUnSolved = TotalUnSolved, Dates = Dates }; // return Json(resultData, JsonRequestBehavior.AllowGet); //return Json(c, JsonRequestBehavior.AllowGet); return(Json(output, JsonRequestBehavior.AllowGet)); }
static async Task <Microsoft.WindowsAzure.Storage.Table.CloudTable> GetTable(string tableName) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( Constants.StorageConnection); Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); Microsoft.WindowsAzure.Storage.Table.CloudTable table = tableClient.GetTableReference(tableName); await table.CreateIfNotExistsAsync(); return(table); }
public TagIdGroupBolt() { Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = GetStorageAccount(); // Create the table client. Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); this.table = tableClient.GetTableReference("tagId"); this.table.CreateIfNotExists(); }
public ReportGroupCompletnessBolt() { Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = GetStorageAccount(); // Create the table client. Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); this.table = tableClient.GetTableReference("reportCompletness"); this.table.CreateIfNotExists(); }
public ActionResult userquestion(string SDate, string EDate, string Userid) { string TotalSolved = String.Empty; string TotalUnSolved = String.Empty; string Dates = String.Empty; List <SolutionProvidedReportValues> IsSolvedRecordJson = new List <SolutionProvidedReportValues>(); List <SolutionResult> ResultRecordJson = new List <SolutionResult>(); DataTable dt = new DataTable(); dt.Clear(); dt.Columns.Add("Userid"); dt.Columns.Add("Issue"); dt.Columns.Add("Dates"); dt.Columns.Add("Status"); dt.Columns.Add("TotalRating"); try { string a = Convert.ToString(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("SolutionProvidedReport"); string StartdateString = SDate; //"2018-10-25T00:00:00.000Z"; string EnddateString = EDate; //"2018-11-10T00:00:00.000Z"; DateTime StartDate = DateTime.Parse(StartdateString, System.Globalization.CultureInfo.InvariantCulture); DateTime EndDate = DateTime.Parse(EnddateString, System.Globalization.CultureInfo.InvariantCulture); List <SolutionProvidedReport> SutdentListObj = RetrieveEntity <SolutionProvidedReport>(); var SutdentListObj1 = SutdentListObj.Where(item => (item.Timestamp >= StartDate && item.Timestamp <= EndDate) && item.UserId == Userid).OrderByDescending(item => item.Timestamp).ToList(); foreach (var singleData in SutdentListObj1) { DataRow _rvi = dt.NewRow(); _rvi["Userid"] = singleData.UserId; _rvi["Issue"] = singleData.Issue; _rvi["Status"] = singleData.IsSolved; _rvi["TotalRating"] = singleData.Rating; _rvi["Dates"] = Convert.ToDateTime(singleData.Timestamp.DateTime).ToString("dd-MMM-yyyy"); dt.Rows.Add(_rvi); } } catch (Exception ex) { Utility.Utility.GenrateLog(ex.Message); } finally { } if (dt.Rows.Count > 0) { ExcelExport(dt, SDate, EDate, "userquestion_" + Userid + "_"); } return(Redirect("/top10/top10")); }
public WordCountBolt() { name = (new Random(DateTime.Now.Millisecond)).Next(); Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = GetStorageAccount(); // Create the table client. Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); this.table = tableClient.GetTableReference("wordcount"); this.table.CreateIfNotExists(); }
public async Task SaveBench(WalkToSave entityToSave) { CloudStorageAccount account = CloudStorageAccount.Parse(_storageConfig.TableConnectionString); CloudTableClient tableClient = account.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference(_storageConfig.MetadataTableName); await table.CreateIfNotExistsAsync(); var result = await InsertEntity(table, entityToSave); if (result.HttpStatusCode != (int)HttpStatusCode.NoContent) { throw new ApplicationException("Failed to insert entity in database."); } }
public async Task <JsonResult> GetTop10DetectedIntent(string SDate, string EDate) { string TotalSolved = String.Empty; string TotalUnSolved = String.Empty; string Dates = String.Empty; List <SolutionProvidedReportValues> IsSolvedRecordJson = new List <SolutionProvidedReportValues>(); List <SolutionResult> ResultRecordJson = new List <SolutionResult>(); try { string a = Convert.ToString(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the table client. Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Retrieve a reference to the table. // CloudTable table = tableClient.GetTableReference("SolutionProvidedReport"); table = tableClient.GetTableReference("SolutionProvidedReport"); await table.CreateIfNotExistsAsync(); string StartdateString = SDate; string EnddateString = EDate; DateTime StartDate = DateTime.Parse(StartdateString, System.Globalization.CultureInfo.InvariantCulture); DateTime EndDate = DateTime.Parse(EnddateString, System.Globalization.CultureInfo.InvariantCulture); List <SolutionProvidedReport> SutdentListObj = RetrieveEntity <SolutionProvidedReport>(); var SutdentListObj1 = SutdentListObj.Where(item => item.Timestamp >= StartDate && item.Timestamp <= EndDate).OrderByDescending(item => item.Timestamp).GroupBy(item => item.DetectedIntent).Take(10).OrderByDescending(g => g.Count()).ToList(); foreach (var singleData in SutdentListObj1) { SolutionProvidedReportValues DataList = new SolutionProvidedReportValues(); SolutionResult resultdata = new SolutionResult(); DataList.DetectedIntent = (singleData.Key).ToString(); DataList.Values = singleData.Count(); resultdata.DetectedIntent += DataList.DetectedIntent; resultdata.DetectedIntentCount += DataList.Values; ResultRecordJson.Add(resultdata); } } catch (Exception ex) { Utility.Utility.GenrateLog(ex.Message); } finally { } var output = JsonConvert.SerializeObject(ResultRecordJson); return(Json(output, JsonRequestBehavior.AllowGet)); }
public ActionResult Top10DetectedIntentExport(string SDate, string EDate) { string TotalSolved = String.Empty; string TotalUnSolved = String.Empty; string Dates = String.Empty; List <SolutionProvidedReportValues> IsSolvedRecordJson = new List <SolutionProvidedReportValues>(); List <SolutionResult> ResultRecordJson = new List <SolutionResult>(); DataTable dt = new DataTable(); dt.Clear(); dt.Columns.Add("DetectedIntent"); dt.Columns.Add("DetectedIntentCount"); try { string a = Convert.ToString(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("SolutionProvidedReport"); string StartdateString = SDate; //"2018-10-25T00:00:00.000Z"; string EnddateString = EDate; //"2018-11-10T00:00:00.000Z"; DateTime StartDate = DateTime.Parse(StartdateString, System.Globalization.CultureInfo.InvariantCulture); DateTime EndDate = DateTime.Parse(EnddateString, System.Globalization.CultureInfo.InvariantCulture); List <SolutionProvidedReport> SutdentListObj = RetrieveEntity <SolutionProvidedReport>(); var SutdentListObj1 = SutdentListObj.Where(item => item.Timestamp >= StartDate && item.Timestamp <= EndDate).OrderByDescending(item => item.Timestamp).GroupBy(item => item.DetectedIntent).Take(10).OrderByDescending(g => g.Count()).ToList(); foreach (var singleData in SutdentListObj1) { SolutionProvidedReportValues DataList = new SolutionProvidedReportValues(); DataList.DetectedIntent = (singleData.Key).ToString(); DataList.Values = singleData.Count(); DataRow _rvi = dt.NewRow(); _rvi["DetectedIntent"] = DataList.DetectedIntent; _rvi["DetectedIntentCount"] = DataList.Values; dt.Rows.Add(_rvi); } } catch (Exception ex) { Utility.Utility.GenrateLog(ex.Message); } finally { } if (dt.Rows.Count > 0) { ExcelExport(dt, SDate, EDate, "TOP10DetectedIntent"); } return(Redirect("/top10/top10")); }
public Microsoft.WindowsAzure.Storage.Table.CloudTable GetTable(string tableName) { Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse( StorageConnectionString); ServicePoint tableServicePoint = ServicePointManager.FindServicePoint(storageAccount.TableEndpoint); tableServicePoint.UseNagleAlgorithm = false; Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Create the table if it doesn't exist. CloudTable table = tableClient.GetTableReference(tableName); table.CreateIfNotExistsAsync().Wait(); return(table); }
public async Task <List <WalkToSave> > GetAllEntities() { CloudStorageAccount account = CloudStorageAccount.Parse(_storageConfig.TableConnectionString); CloudTableClient tableClient = account.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference(_storageConfig.MetadataTableName); await table.CreateIfNotExistsAsync(); var query = new TableQuery <WalkToSave>(); var entities = new List <WalkToSave>(); TableContinuationToken token = null; TableQuerySegment <WalkToSave> resultSegment = null; do { resultSegment = await table.ExecuteQuerySegmentedAsync <WalkToSave>(query, token); entities.AddRange(resultSegment.Results.OfType <WalkToSave>()); token = resultSegment.ContinuationToken; }while (token != null); return(entities); }
public Boolean UserAuthentication(string UserId, string Password) { Boolean _result = false; string TotalSolved = String.Empty; string TotalUnSolved = String.Empty; string Dates = String.Empty; List <SolutionProvidedReportValues> IsSolvedRecordJson = new List <SolutionProvidedReportValues>(); List <SolutionResult> ResultRecordJson = new List <SolutionResult>(); try { string a = Convert.ToString(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("ReportsUsers"); // await table.CreateIfNotExistsAsync(); List <HomeLoginViewModel> SutdentListObj = RetrieveEntity <HomeLoginViewModel>(); var SutdentListObj1 = SutdentListObj.Where(item => item.Username == UserId && item.Password == Password).ToList(); if (SutdentListObj1.Count > 0) { _result = true; } } catch (Exception ex) { Utility.Utility.GenrateLog(ex.Message); } finally { } return(_result); }
private static RESTCommand <TableResult> RetrieveImpl(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions requestOptions) { requestOptions.AssertPolicyIfRequired(); RESTCommand <TableResult> retrieveCmd = new RESTCommand <TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, table.Name)); requestOptions.ApplyToStorageCommand(retrieveCmd); TableResult result = new TableResult(); if (operation.SelectColumns != null && operation.SelectColumns.Count > 0) { // If encryption policy is set, then add the encryption metadata column to Select columns in order to be able to decrypt properties. if (requestOptions.EncryptionPolicy != null) { operation.SelectColumns.Add(Constants.EncryptionConstants.TableEncryptionKeyDetails); operation.SelectColumns.Add(Constants.EncryptionConstants.TableEncryptionPropertyDetails); } retrieveCmd.Builder = operation.GenerateQueryBuilder(requestOptions.ProjectSystemProperties); } retrieveCmd.CommandLocationMode = operation.isPrimaryOnlyRetrieve ? CommandLocationMode.PrimaryOnly : CommandLocationMode.PrimaryOrSecondary; retrieveCmd.RetrieveResponseStream = true; retrieveCmd.SignRequest = client.AuthenticationHandler.SignRequest; retrieveCmd.ParseError = ODataErrorHelper.ReadFromStreamUsingODataLib; retrieveCmd.BuildRequestDelegate = (uri, builder, timeout, useVersionHeader, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, useVersionHeader, ctx, requestOptions, client.AccountName).Item1; retrieveCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex); retrieveCmd.PostProcessResponse = (cmd, resp, ctx) => { if (resp.StatusCode == HttpStatusCode.NotFound) { return(result); } result = TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx, requestOptions, client.AccountName); return(result); }; return(retrieveCmd); }
public static async Task MyClassInitialize(TestContext testContext) { CloudTableClient tableClient = GenerateCloudTableClient(); currentTable = tableClient.GetTableReference(GenerateRandomTableName()); await currentTable.CreateIfNotExistsAsync(); // Bulk Query Entities for (int i = 0; i < 15; i++) { TableBatchOperation batch = new TableBatchOperation(); for (int j = 0; j < 100; j++) { var ent = GenerateRandomEnitity("tables_batch_" + i.ToString()); ent.RowKey = string.Format("{0:0000}", j); batch.Insert(ent); } await currentTable.ExecuteBatchAsync(batch); } complexEntityTable = tableClient.GetTableReference(GenerateRandomTableName()); await complexEntityTable.CreateAsync(); // Setup TableBatchOperation complexBatch = new TableBatchOperation(); string pk = Guid.NewGuid().ToString(); for (int m = 0; m < 100; m++) { ComplexEntity complexEntity = new ComplexEntity(pk, string.Format("{0:0000}", m)); complexEntity.String = string.Format("{0:0000}", m); complexEntity.Binary = new byte[] { 0x01, 0x02, (byte)m }; complexEntity.BinaryPrimitive = new byte[] { 0x01, 0x02, (byte)m }; complexEntity.Bool = m % 2 == 0 ? true : false; complexEntity.BoolPrimitive = m % 2 == 0 ? true : false; complexEntity.Double = m + ((double)m / 100); complexEntity.DoublePrimitive = m + ((double)m / 100); complexEntity.Int32 = m; complexEntity.Int32N = m; complexEntity.IntegerPrimitive = m; complexEntity.IntegerPrimitiveN = m; complexEntity.Int64 = (long)int.MaxValue + m; complexEntity.LongPrimitive = (long)int.MaxValue + m; complexEntity.LongPrimitiveN = (long)int.MaxValue + m; complexEntity.Guid = Guid.NewGuid(); complexBatch.Insert(complexEntity); if (m == 50) { middleRef = complexEntity; } // Add delay to make times unique Thread.Sleep(100); } await complexEntityTable.ExecuteBatchAsync(complexBatch); }
internal Task <IList <TableResult> > ExecuteAsync(CloudTableClient client, string tableName, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
private static RESTCommand <IList <TableResult> > BatchImpl(TableBatchOperation batch, CloudTableClient client, string tableName, TableRequestOptions requestOptions) { RESTCommand <IList <TableResult> > batchCmd = new RESTCommand <IList <TableResult> >(client.Credentials, client.StorageUri); requestOptions.ApplyToStorageCommand(batchCmd); List <TableResult> results = new List <TableResult>(); batchCmd.CommandLocationMode = batch.ContainsWrites ? CommandLocationMode.PrimaryOnly : CommandLocationMode.PrimaryOrSecondary; batchCmd.RetrieveResponseStream = true; batchCmd.Handler = client.AuthenticationHandler; batchCmd.BuildClient = HttpClientFactory.BuildHttpClient; batchCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib; batchCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableBatchOperation(cmd, uri, builder, serverTimeout, tableName, batch, client, cnt, ctx, requestOptions.PayloadFormat.Value); batchCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp.StatusCode, results, cmd, ex); batchCmd.PostProcessResponse = (cmd, resp, ctx) => TableOperationHttpResponseParsers.TableBatchOperationPostProcess(results, batch, cmd, resp, ctx, requestOptions, client.AccountName); batchCmd.RecoveryAction = (cmd, ex, ctx) => results.Clear(); return(batchCmd); }
public async Task CloudTableTestValidCorsRulesAsync() { CorsRule ruleMinRequired = new CorsRule() { AllowedOrigins = new List <string>() { "www.xyz.com" }, AllowedMethods = CorsHttpMethods.Get }; CorsRule ruleBasic = new CorsRule() { AllowedOrigins = new List <string>() { "www.ab.com", "www.bc.com" }, AllowedMethods = CorsHttpMethods.Get | CorsHttpMethods.Put, MaxAgeInSeconds = 500, ExposedHeaders = new List <string>() { "x-ms-meta-data*", "x-ms-meta-source*", "x-ms-meta-abc", "x-ms-meta-bcd" }, AllowedHeaders = new List <string>() { "x-ms-meta-data*", "x-ms-meta-target*", "x-ms-meta-xyz", "x-ms-meta-foo" } }; CorsRule ruleAllMethods = new CorsRule() { AllowedOrigins = new List <string>() { "www.xyz.com" }, AllowedMethods = CorsHttpMethods.Put | CorsHttpMethods.Trace | CorsHttpMethods.Connect | CorsHttpMethods.Delete | CorsHttpMethods.Get | CorsHttpMethods.Head | CorsHttpMethods.Options | CorsHttpMethods.Post | CorsHttpMethods.Merge }; CorsRule ruleSingleExposedHeader = new CorsRule() { AllowedOrigins = new List <string>() { "www.ab.com" }, AllowedMethods = CorsHttpMethods.Get, ExposedHeaders = new List <string>() { "x-ms-meta-bcd" }, }; CorsRule ruleSingleExposedPrefixHeader = new CorsRule() { AllowedOrigins = new List <string>() { "www.ab.com" }, AllowedMethods = CorsHttpMethods.Get, ExposedHeaders = new List <string>() { "x-ms-meta-data*" }, }; CorsRule ruleSingleAllowedHeader = new CorsRule() { AllowedOrigins = new List <string>() { "www.ab.com" }, AllowedMethods = CorsHttpMethods.Get, AllowedHeaders = new List <string>() { "x-ms-meta-xyz", }, }; CorsRule ruleSingleAllowedPrefixHeader = new CorsRule() { AllowedOrigins = new List <string>() { "www.ab.com" }, AllowedMethods = CorsHttpMethods.Get, AllowedHeaders = new List <string>() { "x-ms-meta-target*" }, }; CorsRule ruleAllowAll = new CorsRule() { AllowedOrigins = new List <string>() { "*" }, AllowedMethods = CorsHttpMethods.Get, AllowedHeaders = new List <string>() { "*" }, ExposedHeaders = new List <string>() { "*" } }; CloudTableClient client = GenerateCloudTableClient(); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleBasic }); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleMinRequired }); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleAllMethods }); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleSingleExposedHeader }); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleSingleExposedPrefixHeader }); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleSingleAllowedHeader }); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleSingleAllowedPrefixHeader }); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleAllowAll }); // Empty rule set should delete all rules await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { }); // Test duplicate rules await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleBasic, ruleBasic }); // Test max number of rules (five) await this.TestCorsRulesAsync( client, null, new List <CorsRule>() { ruleBasic, ruleMinRequired, ruleAllMethods, ruleSingleExposedHeader, ruleSingleExposedPrefixHeader }); // Test max number of rules + 1 (six) OperationContext context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await this.TestCorsRulesAsync( client, context, new List <CorsRule>() { ruleBasic, ruleMinRequired, ruleAllMethods, ruleSingleExposedHeader, ruleSingleExposedPrefixHeader, ruleSingleAllowedHeader }), context, "Services are limited to a maximum of five CORS rules.", HttpStatusCode.BadRequest, "InvalidXmlDocument"); }
public async Task <JsonResult> GetAvgRatingReport(string SDate, string EDate) { string TotalSolved = String.Empty; string TotalUnSolved = String.Empty; string Dates = String.Empty; List <SolutionProvidedReportValues> IsSolvedRecordJson = new List <SolutionProvidedReportValues>(); List <SolutionResult> ResultRecordJson = new List <SolutionResult>(); try { string a = Convert.ToString(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the table client. Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("SolutionProvidedReport"); await table.CreateIfNotExistsAsync(); string StartdateString = SDate; //"2018-10-25T00:00:00.000Z"; string EnddateString = EDate; // "2018-11-10T00:00:00.000Z"; DateTime StartDate = DateTime.Parse(StartdateString, System.Globalization.CultureInfo.InvariantCulture); DateTime EndDate = DateTime.Parse(EnddateString, System.Globalization.CultureInfo.InvariantCulture); List <SolutionProvidedReport> SutdentListObj = RetrieveEntity <SolutionProvidedReport>(); var SutdentListObj1 = SutdentListObj.Where(item => item.Timestamp >= StartDate && item.Timestamp <= EndDate).OrderByDescending(item => item.Timestamp).GroupBy(item => item.Timestamp.Date).ToList(); // .Select(g => new { // Date = g.Key, // Count = g.Count(), // Total = g.Sum(i => i.Rating), // Average = g.Average(i => i.Rating) //}).ToList(); foreach (var singleData in SutdentListObj1) { SolutionProvidedReportValues DataList = new SolutionProvidedReportValues(); SolutionResult resultdata = new SolutionResult(); DataList.Timestamp1 = (singleData.Key).ToString(); foreach (var result in singleData) { if (result.Rating > 0) { DataList.RatingTotal += result.Rating; DataList.RatingCount += 1; } else { DataList.isSolvedFalse += 1; } } if (DataList.RatingTotal > 0 && DataList.RatingCount > 0) { resultdata.AvgRating += (DataList.RatingTotal / DataList.RatingCount); } else { resultdata.AvgRating = 0; } resultdata.Dates += Convert.ToDateTime(DataList.Timestamp1).ToString("dd MMM");// + ", "; ResultRecordJson.Add(resultdata); } } catch (Exception ex) { Utility.Utility.GenrateLog(ex.Message); } finally { } var output = JsonConvert.SerializeObject(ResultRecordJson); return(Json(output, JsonRequestBehavior.AllowGet)); }
private static RESTCommand <IList <TableResult> > BatchImpl(TableBatchOperation batch, CloudTableClient client, CloudTable table, TableRequestOptions requestOptions) { RESTCommand <IList <TableResult> > batchCmd = new RESTCommand <IList <TableResult> >(client.Credentials, client.StorageUri); requestOptions.ApplyToStorageCommand(batchCmd); List <TableResult> results = new List <TableResult>(); batchCmd.CommandLocationMode = batch.ContainsWrites ? CommandLocationMode.PrimaryOnly : CommandLocationMode.PrimaryOrSecondary; batchCmd.RetrieveResponseStream = true; batchCmd.SignRequest = client.AuthenticationHandler.SignRequest; batchCmd.ParseError = ODataErrorHelper.ReadFromStreamUsingODataLib; batchCmd.BuildRequestDelegate = (uri, builder, timeout, useVersionHeader, ctx) => { Tuple <HttpWebRequest, Stream> res = TableOperationHttpWebRequestFactory.BuildRequestForTableBatchOperation(uri, builder, client.BufferManager, timeout, table.Name, batch, useVersionHeader, ctx, requestOptions); batchCmd.SendStream = res.Item2; batchCmd.StreamToDispose = res.Item2; return(res.Item1); }; batchCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp != null ? resp.StatusCode : HttpStatusCode.Unused, results, cmd, ex); batchCmd.PostProcessResponse = (cmd, resp, ctx) => TableOperationHttpResponseParsers.TableBatchOperationPostProcess(results, batch, cmd, resp, ctx, requestOptions, client.AccountName); batchCmd.RecoveryAction = (cmd, ex, ctx) => results.Clear(); return(batchCmd); }
internal Task <TableQuerySegment> ExecuteQuerySegmentedAsync(TableContinuationToken continuationToken, CloudTableClient client, string tableName, TableRequestOptions requestOptions, OperationContext operationContext) { return(ExecuteQuerySegmentedAsync(continuationToken, client, tableName, requestOptions, operationContext, CancellationToken.None)); }
internal Task <TableQuerySegment> ExecuteQuerySegmentedAsync(TableContinuationToken continuationToken, CloudTableClient client, string tableName, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken) { CommonUtility.AssertNotNullOrEmpty("tableName", tableName); TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client); operationContext = operationContext ?? new OperationContext(); RESTCommand <TableQuerySegment> cmdToExecute = QueryImpl(this, continuationToken, client, tableName, EntityUtilities.ResolveEntityByType <DynamicTableEntity>, modifiedOptions); return(Task.Run(async() => await Executor.ExecuteAsync( cmdToExecute, modifiedOptions.RetryPolicy, operationContext, cancellationToken), cancellationToken)); }
private static RESTCommand <TableQuerySegment> QueryImpl(TableQuery query, TableContinuationToken token, CloudTableClient client, string tableName, EntityResolver <DynamicTableEntity> resolver, TableRequestOptions requestOptions) { UriQueryBuilder builder = query.GenerateQueryBuilder(requestOptions.ProjectSystemProperties); 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.Builder = builder; queryCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib; queryCmd.BuildRequest = (cmd, uri, queryBuilder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableQuery(uri, builder, serverTimeout, cnt, ctx, requestOptions.PayloadFormat.Value, client.GetCanonicalizer(), client.Credentials); queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp.StatusCode, null /* retVal */, cmd, ex); queryCmd.PostProcessResponse = async(cmd, resp, ctx) => { ResultSegment <DynamicTableEntity> resSeg = await TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <DynamicTableEntity>(cmd.ResponseStream, resolver.Invoke, resp, requestOptions, ctx, client.AccountName); if (resSeg.ContinuationToken != null) { resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation; } return(new TableQuerySegment(resSeg)); }; return(queryCmd); }
public void ListTablesWithPrefixExtended() { CloudTableClient tableClient = GenerateCloudTableClient(); int NumTables = 50; int TableNameLength = 8; int NumQueries = 100; string alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; string numerics = "0123456789"; string legalChars = alpha + numerics; string queryString = string.Empty; List <CloudTable> tableList = new List <CloudTable>(); List <CloudTable> localTestCreatedTableList = new List <CloudTable>(); Random rand = new Random(); try { #region Generate Tables // Generate Tables in Storage // This will generate all caps Tables, i.e. AAAAAAAA, BBBBBBBB.... for (int h = 26; h < alpha.Length; h++) { string tString = string.Empty; for (int i = 0; i < TableNameLength; i++) { tString += alpha[h]; } CloudTable table = tableClient.GetTableReference(tString); if (table.CreateIfNotExists()) { tableList.Add(table); localTestCreatedTableList.Add(table); } } // Generate some random tables of TableNameLength, table must start with a letter for (int m = 0; m < NumTables; m++) { string tableName = GenerateRandomStringFromCharset(1, alpha, rand).ToLower() + GenerateRandomStringFromCharset(TableNameLength - 1, legalChars, rand).ToLower(); CloudTable table = tableClient.GetTableReference(tableName); if (table.CreateIfNotExists()) { tableList.Add(table); localTestCreatedTableList.Add(table); } } #endregion #region Generate Query Strings to cover all boundary conditions List <string> queryStrings = new List <string>() { String.Empty, "aa", "zz", "az", "Az", "Aa", "zZ", "AA", "ZZ", "AZ", "z9", "a9", "aaa" }; for (int k = 0; k < legalChars.Length; k++) { queryStrings.Add(legalChars[k].ToString()); } for (int n = 0; n <= NumQueries; n++) { queryStrings.Add(GenerateRandomStringFromCharset((n % TableNameLength) + 1, legalChars, rand)); } #endregion #region Merge Created Tables With Pre-existing ones int totalTables = 0; foreach (CloudTable listedTable in tableClient.ListTables()) { totalTables++; if (tableList.Where((tbl) => tbl.Uri == listedTable.Uri).FirstOrDefault() != null) { continue; } tableList.Add(listedTable); } Assert.AreEqual(tableList.Count, totalTables); #endregion List <CloudTable> serviceResult = null; List <CloudTable> LINQResult = null; try { foreach (string queryValue in queryStrings) { queryString = queryValue; serviceResult = tableClient.ListTables(queryString).OrderBy((table) => table.Name).ToList(); LINQResult = tableList.Where((table) => table.Name.ToLower().StartsWith(queryString.ToLower())).OrderBy((table) => table.Name).ToList(); Assert.AreEqual(serviceResult.Count(), LINQResult.Count()); for (int listDex = 0; listDex < serviceResult.Count(); listDex++) { Assert.AreEqual(serviceResult[listDex].Name, LINQResult[listDex].Name); } } } catch (Exception) { // On exception log table names for repro this.testContextInstance.WriteLine("Exception in ListTablesWithPrefix, Dumping Tables for repro. QueryString = {0}\r\n", queryString); foreach (CloudTable table in tableList) { this.testContextInstance.WriteLine(table.Name); } this.testContextInstance.WriteLine("Linq results ======================="); foreach (CloudTable table in LINQResult) { this.testContextInstance.WriteLine(table.Name); } this.testContextInstance.WriteLine("Service results ======================="); foreach (CloudTable table in serviceResult) { this.testContextInstance.WriteLine(table.Name); } throw; } } finally { // Cleanup foreach (CloudTable table in localTestCreatedTableList) { // Dont delete Class level tables if (createdTables.Where((tbl) => tbl.Uri == table.Uri).FirstOrDefault() != null) { continue; } // Delete other tables table.DeleteIfExists(); } } }
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <T, RESULT_TYPE>(TableQuery <T> query, TableContinuationToken token, CloudTableClient client, string tableName, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions) where T : ITableEntity, new() { UriQueryBuilder builder = query.GenerateQueryBuilder(); if (token != null) { token.ApplyToUriQueryBuilder(builder); } StorageUri tempUri = NavigationHelper.AppendPathToUri(client.StorageUri, tableName); RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, tempUri); 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) => { ResultSegment <RESULT_TYPE> resSeg = await TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE>(cmd.ResponseStream, resolver.Invoke, resp, ctx); if (resSeg.ContinuationToken != null) { resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation; } return(new TableQuerySegment <RESULT_TYPE>(resSeg)); }; return(queryCmd); }
static void Main(string[] args) { var accountName = args[0]; var accountKey = args[1]; var GifsDir = args[2]; storageAccount = CloudStorageAccount.Parse(String.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", accountName, accountKey)); // Create the blob client. CloudBlobClient blobClient = new CloudBlobClient(storageAccount.BlobEndpoint, storageAccount.Credentials); // Create blob container if it doesn't exist. CloudBlobContainer blobContainer = blobClient.GetContainerReference("memes"); blobContainer.CreateIfNotExists(BlobContainerPublicAccessType.Container); // Create the table client. CloudTableClient tableClient = new Microsoft.WindowsAzure.Storage.Table.CloudTableClient(storageAccount.TableEndpoint, storageAccount.Credentials); // Create the table if it doesn't exist. CloudTable table = tableClient.GetTableReference("MemeMetadata"); var statusTable = table.CreateIfNotExists(); var list = new List <ClipMemeEntity> { new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200312-horse-cannon.gif", BlobName = "20140401-200312-horse-cannon.gif", Description = "Deploy", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200344-updated-visual-studio-theme.gif", BlobName = "20140401-200344-updated-visual-studio-theme.gif", Description = "News vs Theme", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200447-oops.gif", BlobName = "20140401-200447-oops.gif", Description = "First Iteration", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200534-just-learned-about-git-rebase.gif", BlobName = "20140401-200534-just-learned-about-git-rebase.gif", Description = "Tests Pass on First Try", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200606-when-i-unstash-something.gif", BlobName = "20140401-200606-when-i-unstash-something.gif", Description = "Scale up", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200750-dog-race.gif", BlobName = "20140401-200750-dog-race.gif", Description = "Sprint", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200800-cookies.gif", BlobName = "20140401-200800-cookies.gif", Description = "Scottgu Promoted", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200849-when-i-merge-my-own-pull-requests.gif", BlobName = "20140401-200849-when-i-merge-my-own-pull-requests.gif", Description = "to the cloud", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-200924-disco-girl.gif", BlobName = "20140401-200924-disco-girl.gif", Description = "Hanseldance", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-201030-when-someone-merges-your-pull-request-before-its-ready.gif", BlobName = "20140401-201030-when-someone-merges-your-pull-request-before-its-ready.gif", Description = "accidental git push", Username = "******" }, new ClipMemeEntity { BlobUri = "https://clipmeme2014.blob.core.windows.net/memes/20140401-201102-Fat-Dance-Suit-Men-Rave-On-At-Home.gif", BlobName = "20140401-201102-Fat-Dance-Suit-Men-Rave-On-At-Home.gif", Description = "msft at $40", Username = "******" } }; foreach (var item in list) { // Retrieve reference to a blob CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(item.BlobName); using (var fileStream = System.IO.File.OpenRead(String.Format("{0}\\{1}", GifsDir, item.BlobName))) { blockBlob.UploadFromStream(fileStream); } var requestOptions = new Microsoft.WindowsAzure.Storage.Table.TableRequestOptions() { RetryPolicy = new Microsoft.WindowsAzure.Storage.RetryPolicies.LinearRetry(TimeSpan.FromMilliseconds(500), 5) }; table.Execute(Microsoft.WindowsAzure.Storage.Table.TableOperation.Insert(item), requestOptions); } return; }
public static void MyClassInitialize(TestContext testContext) { client = GenerateCloudTableClient(); startProperties = client.GetServicePropertiesAsync().AsTask().Result; }
private static RESTCommand <TableResult> ReplaceImpl(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions requestOptions) { RESTCommand <TableResult> replaceCmd = new RESTCommand <TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, table.Name)); requestOptions.ApplyToStorageCommand(replaceCmd); TableResult result = new TableResult() { Result = operation.Entity }; replaceCmd.RetrieveResponseStream = false; replaceCmd.SignRequest = client.AuthenticationHandler.SignRequest; replaceCmd.ParseError = ODataErrorHelper.ReadFromStreamUsingODataLib; replaceCmd.BuildRequestDelegate = (uri, builder, timeout, useVersionHeader, ctx) => { Tuple <HttpWebRequest, Stream> res = TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, useVersionHeader, ctx, requestOptions, client.AccountName); replaceCmd.SendStream = res.Item2; return(res.Item1); }; replaceCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex); return(replaceCmd); }
public async Task CloudTableTestCorsMaxHeadersAsync() { CorsRule ruleManyHeaders = new CorsRule() { AllowedOrigins = new List <string>() { "www.xyz.com" }, AllowedMethods = CorsHttpMethods.Get, AllowedHeaders = new List <string>() { "x-ms-meta-target*", "x-ms-meta-other*" }, ExposedHeaders = new List <string>() { "x-ms-meta-data*", "x-ms-meta-source*" } }; // Add maximum number of non-prefixed headers for (int i = 0; i < 64; i++) { ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-" + i); ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-" + i); } CloudTableClient client = GenerateCloudTableClient(); await this.TestCorsRulesAsync(client, null, new List <CorsRule>() { ruleManyHeaders }); // Test with too many Exposed Headers (65) ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-toomany"); OperationContext context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await this.TestCorsRulesAsync(client, context, new List <CorsRule>() { ruleManyHeaders }), context, "A maximum of 64 literal exposed headers are allowed.", HttpStatusCode.BadRequest, "InvalidXmlNodeValue"); ruleManyHeaders.ExposedHeaders.Remove("x-ms-meta-toomany."); // Test with too many Allowed Headers (65) ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-toomany"); await TestHelper.ExpectedExceptionAsync( async() => await this.TestCorsRulesAsync(client, context, new List <CorsRule>() { ruleManyHeaders }), context, "A maximum of 64 literal allowed headers are allowed.", HttpStatusCode.BadRequest, "InvalidXmlNodeValue"); ruleManyHeaders.AllowedHeaders.Remove("x-ms-meta-toomany"); // Test with too many Exposed Prefixed Headers (three) ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-toomany*"); await TestHelper.ExpectedExceptionAsync( async() => await this.TestCorsRulesAsync(client, context, new List <CorsRule>() { ruleManyHeaders }), context, "A maximum of two prefixed exposed headers are allowed.", HttpStatusCode.BadRequest, "InvalidXmlNodeValue"); ruleManyHeaders.ExposedHeaders.Remove("x-ms-meta-toomany*"); // Test with too many Allowed Prefixed Headers (three) ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-toomany*"); await TestHelper.ExpectedExceptionAsync( async() => await this.TestCorsRulesAsync(client, context, new List <CorsRule>() { ruleManyHeaders }), context, "A maximum of two prefixed allowed headers are allowed.", HttpStatusCode.BadRequest, "InvalidXmlNodeValue"); ruleManyHeaders.AllowedHeaders.Remove("x-ms-meta-toomany*"); }
internal Task <TableQuerySegment <TElement> > ExecuteQuerySegmentedAsync(TableContinuationToken token, CloudTableClient client, string tableName, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
internal IAsyncOperation <TableQuerySegment <TElement> > ExecuteQuerySegmentedAsync(TableContinuationToken token, CloudTableClient client, string tableName, TableRequestOptions requestOptions, OperationContext operationContext) #endif { CommonUtility.AssertNotNullOrEmpty("tableName", tableName); TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client); operationContext = operationContext ?? new OperationContext(); RESTCommand <TableQuerySegment <TElement> > cmdToExecute = QueryImpl(this, token, client, tableName, EntityUtilities.ResolveEntityByType <TElement>, modifiedOptions); #if ASPNET_K || PORTABLE return(Task.Run(async() => await Executor.ExecuteAsync( cmdToExecute, modifiedOptions.RetryPolicy, operationContext, cancellationToken), cancellationToken)); #else return(AsyncInfo.Run(async(cancellationToken) => await Executor.ExecuteAsync( cmdToExecute, modifiedOptions.RetryPolicy, operationContext, cancellationToken))); #endif }