public Form1() { InitializeComponent(); var contact = NampulaDemoDI.Factory.DBNampula.CreatObject<NampulaDemoDI.BusinessPartnerContact>(); var tbQry = new TableQuery(contact); new Nampula.UI.Helpers.ChooseFromListHelper(editTextContatoId, editTextButtonContatoNome, tbQry, BusinessPartnerContact.FieldsName.Id, BusinessPartnerContact.FieldsName.Name, "Contatos"); }
public virtual void SetUp() { connection.RunAsync(Query.DbCreate("test")).Wait(); connection.RunAsync(Query.Db("test").TableCreate("table")).Wait(); testTable = Query.Db("test").Table<TestObject>("table"); testTable2 = Query.Db("test").Table<TestObject2>("table"); }
public async Task<IEnumerable<Prediction>> GetLatestPrediction(string deviceId) { var storageConnectionString = _settings.StorageConnectionString; var table = await AzureTableStorageHelper.GetTableAsync(storageConnectionString, _settings.PredictionTableName); var startTime = DateTimeOffset.Now.AddSeconds(-TimeOffsetInSeconds).DateTime; var deviceFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId); var timestampFilter = TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThanOrEqual, startTime); var filter = TableQuery.CombineFilters(deviceFilter, TableOperators.And, timestampFilter); TableQuery<PredictionRecord> query = new TableQuery<PredictionRecord>() .Where(filter) .Take(MaxRecordsToReceive) .Select(new[] { "Timestamp", "Rul" }); var result = new Collection<Prediction>(); var entities = table.ExecuteQuery(query) .OrderByDescending(x => x.RowKey) .Take(MaxRecordsToSend); foreach (var entity in entities) { var prediction = new Prediction { DeviceId = entity.PartitionKey, Timestamp = entity.Timestamp.DateTime, RemainingUsefulLife = (int)double.Parse(entity.Rul), Cycles = int.Parse(entity.RowKey) }; result.Add(prediction); } return result.OrderBy(x => x.Cycles); }
protected override void OnNavigatedTo(NavigationEventArgs e) { Sqlite sqlData = new Sqlite(); var plan = (Plans)e.Parameter; Days d; //startDate.Text = "From " + plan.StartDate.Date.ToString("d", DateTimeFormatInfo.InvariantInfo) + " To " + plan.EndDate.Date.ToString("d", DateTimeFormatInfo.InvariantInfo); startDate.Text = "From " + plan.StartDate.ToString("dd/MM/yyyy") + " To " + plan.EndDate.ToString("dd/MM/yyyy"); location.Text = "in " + plan.Location; maxDay.Text = plan.MaxDay.ToString(); if (plan.MaxDay == 0) { addNewEvent.IsEnabled = false; } //DaysList = DayList.getDayList(plan.StartDate, plan.EndDate); // Initialize date instance var queryDay = from pd in sqlData.conn.Table<Days>() where pd.PlanID_FK.Equals(plan.PlanID) select pd; // create date if there is no date if (queryDay.Count<Days>() == 0) { for (int i = 1; i <= Convert.ToInt16(maxDay.Text); i++) { d = new Days(plan.PlanID, "No Activities on this day!", "Day " + i.ToString()); sqlData.conn.Insert(d); } } DaysList = DayList.getDayList(plan); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); connection.RunAsync(Query.DbCreate("test")).Wait(); connection.RunAsync(Query.Db("test").TableCreate("table")).Wait(); testTable = Query.Db("test").Table<TestObject>("table"); connection.Run(testTable.IndexCreate("index1", o => o.Name)); }
public Task<InitialDeviceConfig> GetDevice(string deviceId, string hostName) { var query = new TableQuery<DeviceListEntity>().Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, hostName))); return this.GetDeviceAsync(query); }
public virtual void SetUp() { connection.RunAsync(Query.DbCreate("test")).Wait(); connection.RunAsync(Query.Db("test").TableCreate("table")).Wait(); testTable = Query.Db("test").Table<TestObject>("table"); // Insert more than 1000 objects to test the enumerable loading additional chunks of the sequence var objectList = new List<TestObject>(); for (int i = 0; i < 1005; i++) objectList.Add(new TestObject() { Name = "Object #" + i }); connection.RunAsync(testTable.Insert(objectList)).Wait(); }
public async Task<string> GetSimulationState() { var table = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _simulatorStateTableName); var query = new TableQuery<StateTableEntity>() .Take(1) .Select(new[] { "State" }); var result = table.ExecuteQuery(query); var stateEntity = result.FirstOrDefault(); return stateEntity != null ? stateEntity.State : StartStopConstants.STOPPED; }
public virtual void SetUp() { testTable = Query.Db("test").Table<TestObject>("table"); connection.RunAsync(testTable.Insert(new TestObject[] { new TestObject() { Id = "1", Name = "1", SomeNumber = 1, Children = new TestObject[] { new TestObject() { Name = "C1" } } }, new TestObject() { Id = "2", Name = "2", SomeNumber = 2, Children = new TestObject[] { } }, new TestObject() { Id = "3", Name = "3", SomeNumber = 3, Children = new TestObject[] { new TestObject() { Name = "C3" } } }, new TestObject() { Id = "4", Name = "4", SomeNumber = 4, Children = new TestObject[] { } }, new TestObject() { Id = "5", Name = "5", SomeNumber = 5, Children = new TestObject[] { new TestObject() { Name = "C5" } } }, new TestObject() { Id = "6", Name = "6", SomeNumber = 6, Children = new TestObject[] { } }, new TestObject() { Id = "7", Name = "7", SomeNumber = 7, Children = new TestObject[] { new TestObject() { Name = "C7" } } }, })).Wait(); }
public QuizDatabase(string _databaseName) { var databaseName = _databaseName; var documentsPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal)); var databasePath = Path.Combine(documentsPath, databaseName); isExists = File.Exists(databasePath); connection = new SQLiteConnection(databasePath); if (!isExists) RecoverDatabase(); BranchQuery = connection.Table<Branch>(); QuestionQuery = connection.Table<Question>(); AnswersQuery = connection.Table<OptionAnswers>(); }
public async Task<List<InitialDeviceConfig>> GetDeviceListAsync() { List<InitialDeviceConfig> devices = new List<InitialDeviceConfig>(); var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName); TableQuery<DeviceListEntity> query = new TableQuery<DeviceListEntity>(); foreach (var device in devicesTable.ExecuteQuery(query)) { var deviceConfig = new InitialDeviceConfig { HostName = device.HostName, DeviceId = device.DeviceId, Key = device.Key }; devices.Add(deviceConfig); } return devices; }
public virtual void SetUp() { testTable = Query.Db("test").Table<TestObject>("table1"); anotherTestTable = Query.Db("test").Table<AnotherTestObject>("table2"); connection.RunAsync(testTable.Insert(new TestObject[] { new TestObject() { Id = "1", Name = "1", SomeNumber = 1, Children = new TestObject[1] }, new TestObject() { Id = "2", Name = "2", SomeNumber = 2, Children = new TestObject[2] }, new TestObject() { Id = "3", Name = "3", SomeNumber = 3, Children = new TestObject[3] }, new TestObject() { Id = "4", Name = "4", SomeNumber = 4, Children = new TestObject[4] }, })).Wait(); connection.RunAsync(anotherTestTable.Insert(new AnotherTestObject[] { new AnotherTestObject() { Id = "1", FirstName = "1", LastName = "1" }, new AnotherTestObject() { Id = "2", FirstName = "2", LastName = "2" }, new AnotherTestObject() { Id = "3", FirstName = "3", LastName = "3" }, })).Wait(); }
/// <inheritdoc /> public override async Task <ICollection <WebHook> > GetAllWebHooksAsync(string user) { if (user == null) { throw new ArgumentNullException(nameof(user)); } user = NormalizeKey(user); var table = _manager.GetCloudTable(_connectionString, WebHookTable); var query = new TableQuery(); _manager.AddPartitionKeyConstraint(query, user); var entities = await _manager.ExecuteQueryAsync(table, query); ICollection <WebHook> result = entities.Select(e => ConvertToWebHook(e)) .Where(w => w != null) .ToArray(); return(result); }
public async Task <string> DeleteStudent(string a) { TableOperation insertO = TableOperation.Retrieve(student.PartitionKey, student.RowKey); TableResult query = await studentTable.ExecuteAsync(insertO); object a = query.Result; if (a != null) { TableOperation delete = TableOperation.Delete(student); await studentTable.ExecuteAsync(delete); return("Studentul a fost sters"); } else { return("Studentul nu exista"); } var students = new List <StudentEntity>(); TableQuery <StudentEntity> query1 = new TableQuery <StudentEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, a)); TableQuerySegment <StudentEntity> resultSegment = await studentTable.ExecuteQuerySegmentedAsync(query1, null); students.AddRange(resultSegment.Results); object v = students.Count; if (students.Count != 0) { TableOperation delete = TableOperation.Delete(students[0]); await studentTable.ExecuteAsync(delete); return("Studentul a fost sters"); } else { return("Studentul nu exista"); } }
public TableQuery GetTableQuery(string lowerBoundPartitionKey, string upperBoundPartitionKey) { if (string.IsNullOrEmpty(lowerBoundPartitionKey)) { lowerBoundPartitionKey = "0"; } var lowerBoundDateTime = ConvertPartitionKeyToDateTime(lowerBoundPartitionKey); var upperBoundDateTime = ConvertPartitionKeyToDateTime(upperBoundPartitionKey); _logger.LogDebug($"Generating table query: lowerBound partitionKey={lowerBoundPartitionKey} ({lowerBoundDateTime}), upperBound partitionKey={upperBoundPartitionKey} ({upperBoundDateTime})"); var lowerBound = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.GreaterThanOrEqual, lowerBoundPartitionKey); var upperBound = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.LessThan, upperBoundPartitionKey); var combinedFilter = TableQuery.CombineFilters(lowerBound, TableOperators.And, upperBound); var query = new TableQuery() .Where(combinedFilter) .Select(new[] { "PartitionKey", "RowKey" }); return(query); }
static void Main(string[] args) { TableQuery tableQuery = new TableQuery(); tableQuery.Take(100); tableQuery.FilterString = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "1"), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, "2")); try { CloudStorageAccount sta = CloudStorageAccount.Parse(""); CloudTableClient tableClient = sta.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference("TestQuestionnaireComments"); var result = table.ExecuteQuery(tableQuery).ToList().FirstOrDefault(); Int64 highestVal = Int64.MinValue; foreach (var item in result.Properties) { if (highestVal == Int64.MinValue) { highestVal = Convert.ToInt64(item.Key.Substring(1)); } else if (highestVal < Convert.ToInt64(item.Key.Substring(1))) { highestVal = Convert.ToInt64(item.Key.Substring(1)); } } Console.WriteLine($"The latest comments is {result.Properties["A"+highestVal.ToString()]}"); } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { Console.WriteLine("Prees any Key to close ......................"); Console.ReadKey(); } }
private async Task ExecuteQueryAsync(string processName, TableQuery <T> rangeQuery, Func <T, bool> filter, Func <IEnumerable <T>, Task> yieldData) { try { TableContinuationToken tableContinuationToken = null; var table = GetTable(); do { var queryResponse = await table.ExecuteQuerySegmentedAsync(rangeQuery, tableContinuationToken); tableContinuationToken = queryResponse.ContinuationToken; await yieldData(AzureStorageUtils.ApplyFilter(queryResponse.Results, filter)); } while (tableContinuationToken != null); } catch (Exception ex) { _log?.WriteFatalErrorAsync("Table storage: " + _tableName, processName, rangeQuery.FilterString ?? "[null]", ex).Wait(); throw; } }
public ActionResult OrderHistory(string email) { CloudTable table = getTableStorageInformation(); TableQuery <OrderEntity> query = new TableQuery <OrderEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, email)); List <OrderEntity> orders = new List <OrderEntity>(); TableContinuationToken token = null; do { TableQuerySegment <OrderEntity> resultsSegment = table.ExecuteQuerySegmentedAsync(query, token).Result; foreach (OrderEntity orderEntity in resultsSegment.Results) { orders.Add(orderEntity); } }while (token != null); return(View(orders)); }
/// <summary> /// Retrieve List of T type entity /// </summary> /// <typeparam name="T">Returned Entity Type</typeparam> /// <param name="Query"></param> /// <returns>List of T type object</returns> public List <T> RetrieveEntity <T>(string Query = null) where T : TableEntity, new() { try { TableQuery <T> DataTableQuery = new TableQuery <T>(); if (!string.IsNullOrEmpty(Query)) { DataTableQuery = new TableQuery <T>().Where(Query); } IEnumerable <T> IDataList = table.ExecuteQuery(DataTableQuery); List <T> DataList = new List <T>(); foreach (var singleData in IDataList) { DataList.Add(singleData); } return(DataList); } catch (Exception ExceptionObj) { throw ExceptionObj; } }
public async Task <IReadOnlyDictionary <string, StatusModel> > GetStatiAsync(EmailRequest request, CancellationToken cancellationToken) { await _table.CreateIfNotExistsAsync(null, null, cancellationToken); var partitionMatch = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, StatusModel.GetPartitionKey(request)); var tableQuery = new TableQuery <StatusModel> { FilterString = partitionMatch }; TableContinuationToken token = null; var stati = new List <StatusModel>(); do { var result = await _table.ExecuteQuerySegmentedAsync(tableQuery, null, null, null, cancellationToken); token = result.ContinuationToken; stati.AddRange(result.Results); }while (token != null); return(stati.ToDictionary(x => x.ActionId, x => x)); }
public void InsertIntoTableItem(Item item) { try { using (SQLiteConnection cxn = new SQLiteConnection(DBStore.DBLocation)) { TableQuery <Item> query = cxn.Table <Item>(); if (query.Count() == 0) { //cxn.Insert(new Item("Power Drill", "Powerful Tool", Resource.Drawable.powerdrill)); //cxn.Insert(new Item("Wheelbarrow", "Good condition, can lend for up to 3 days", Resource.Drawable.wheelbarrow)); cxn.Insert(item); } //cxn.Insert(item); } } catch (Exception ex) { Console.WriteLine(ex.Message); throw; } }
public async IAsyncEnumerable <string> GetClassAttendance(string classId) { System.Console.WriteLine("_________________________"); System.Console.WriteLine($"{classId}"); System.Console.WriteLine("_________________________"); var table = await GetTable("student"); TableContinuationToken continuationToken = null; string filter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, classId); do { var queryResult = await table.ExecuteQuerySegmentedAsync(new TableQuery().Where(filter), continuationToken); foreach (var result in queryResult) { yield return(result.RowKey); } continuationToken = queryResult.ContinuationToken; } while (continuationToken != null); }
public async T.Task <IEnumerable <Task> > GetTasksAsync( int jobId, int requeueCount, int lastTaskId, int count = 100, JobType type = JobType.ClusRun, CancellationToken token = default(CancellationToken)) { this.Logger.Information("Get {type} tasks called. getting job {id}", type, jobId); var jobPartitionKey = this.Utilities.GetJobPartitionKey(type, jobId); var partitionQuery = this.Utilities.GetPartitionQueryString(jobPartitionKey); var rowKeyRangeQuery = this.Utilities.GetRowKeyRangeString( this.Utilities.GetTaskKey(jobId, lastTaskId, requeueCount), this.Utilities.GetTaskKey(jobId, int.MaxValue, requeueCount)); var q = TableQuery.CombineFilters(partitionQuery, TableOperators.And, rowKeyRangeQuery); var tasks = await this.jobsTable.QueryAsync <Task>(q, count, token); return(tasks.Where(r => r.Item3.CustomizedData != Task.EndTaskMark).Select(r => r.Item3)); }
public async Task <UsuarioModel> LeerUsuarioCorreo(string Correo) { var table = TablaAzure(); TableQuery <AzUsuarioEntity> query = new TableQuery <AzUsuarioEntity>(); var token = new TableContinuationToken(); var list = new List <ProductoEntity>(); foreach (AzUsuarioEntity az in await table.ExecuteQuerySegmentedAsync(query, token)) { if (az.CorreoElectronico == Correo) { return(new UsuarioModel() { Id = az.Id, CorreoElectronico = az.CorreoElectronico, }); } } return(null); }
public async Task <IEnumerable <UsersStorageEntity> > GetAllAsync() { TableContinuationToken token = null; var query = new TableQuery <UsersTableEntity>(); var resultSet = new List <UsersStorageEntity>(); do { var result = await usersTable.ExecuteQuerySegmentedAsync(query, token); resultSet.AddRange(result.Results.Select(p => new UsersStorageEntity { DogeId = p.DogeId, Username = p.Username, Score = p.Score })); token = result.ContinuationToken; } while (token != null); return(resultSet); }
public async Task <List <Appointment> > GetAppointmentById(string id) { if (Appointment == null) { throw new Exception(); } var appointment = new List <Appointment>(); TableQuery <Appointment> query = new TableQuery <Appointment>().Where(TableQuery.GenerateFilterCondition("Id", QueryComparisons.Equal, id)); TableContinuationToken token = null; do { TableQuerySegment <Appointment> resultSegment = await Appointment.ExecuteQuerySegmentedAsync(query, token); token = resultSegment.ContinuationToken; appointment.AddRange(resultSegment.Results); } while (token != null); return(appointment); }
public ActionResult Users() { List <Users> usersList = new List <Users>(); CloudTable table = tableClient.GetTableReference("usertable"); table.CreateIfNotExists(); TableQuery <Users> query = new TableQuery <Users>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "slack")); var users = table.ExecuteQuery(query); // Print the fields for each customer. foreach (Users entity in users) { TableOperation retrieveOperation = TableOperation.Retrieve <Users>(entity.PartitionKey, entity.RowKey); // Execute the retrieve operation. TableResult retrievedResult = table.Execute(retrieveOperation); var user = (Users)retrievedResult.Result; usersList.Add(user); } return(View(usersList)); }
public async Task <IEnumerable <ConsumptionCounter> > FilterAsync(string queryFilter) { var result = new List <ConsumptionCounter>(); var query = new TableQuery <ConsumptionCounterEntity>().Where(queryFilter); TableContinuationToken token = null; do { var resultSegment = await _consumptionCounterTable.ExecuteQuerySegmentedAsync(query, token); token = resultSegment.ContinuationToken; foreach (var entity in resultSegment.Results) { result.Add(new ConsumptionCounter(entity.PartitionKey, entity.RowKey, entity.Amount )); } } while (token != null); return(result); }
// FYI https://stackoverflow.com/questions/43959589/max-filter-comparisons-in-an-azure-table-query // Use this only when you are sure the result sets are way below than 1000 items public static async Task <IEnumerable <DynamicTableEntity> > GetAllFromPartition( this CloudTable table, string partitionKey, IEnumerable <string> rowKeys = null, TableContinuationToken token = null) { Ensure.ArgumentNotNull(table, nameof(table)); Ensure.ArgumentNotNullOrWhiteSpace(partitionKey, nameof(partitionKey)); TableQuery query; if (rowKeys == null || !rowKeys.Any()) { query = CreateQuery() .Where(TableQuery.GenerateFilterCondition ("PartitionKey", QueryComparisons.Equal, partitionKey)); } else { var rowKeyClause = string.Empty; foreach (var rowQuery in rowKeys.Select(rk => TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rk)) .Take(MAX_FILTER_PARAMETER_COUNT)) { rowKeyClause = string.IsNullOrWhiteSpace(rowKeyClause) ? rowQuery : TableQuery.CombineFilters(rowKeyClause, TableOperators.Or, rowQuery); } query = CreateQuery().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey), TableOperators.And, rowKeyClause)); } var resultSegment = await table.ExecuteQuerySegmentedAsync(query, token) .ConfigureAwait(false); // Ignoring the token for now. return(resultSegment.Results); }
public ActionResult Orders() { CloudTable table = getTableStorageInformation(); TableQuery <OrderEntity> query = new TableQuery <OrderEntity>(); List <OrderEntity> orders = new List <OrderEntity>(); TableContinuationToken token = null; do { TableQuerySegment <OrderEntity> resultsSegment = table.ExecuteQuerySegmentedAsync(query, token).Result; foreach (OrderEntity orderEntity in resultsSegment.Results) { orders.Add(orderEntity); } }while (token != null); return(View(orders)); }
public async Task <User> Login(string email, string password) { await userTable.CreateIfNotExistsAsync(); var filter = TableQuery.GenerateFilterCondition("Email", QueryComparisons.Equal, email); TableQuery <User> query = new TableQuery <User>().Where(filter); var result = await userTable.ExecuteQuerySegmentedAsync(query, null); var user = result.FirstOrDefault(); if (user == null) { return(null); } if (!VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt)) { return(null); } return(user); }
public List <AppInstance> GetAppInstances(string spHostWebDomain) { var table = GetTableStorage(ApplicationConstants.AzureStorage.StorageConnectionString, ApplicationConstants.AzureStorage.TableStorageKey); if (!table.Exists()) { table.CreateIfNotExists(); return(new List <AppInstance>()); } // Construct the query operation for all customer entities where PartitionKey="Smith". var query = new TableQuery <AppInstanceEntity>() .Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, spHostWebDomain)); // Print the fields for each customer. var appInstances = table.ExecuteQuery(query) .Select(entity => new AppInstance(entity)) .ToList(); return(appInstances); }
public async Task <IEnumerable <Alert> > GetAllAlerts() { if (alertsTable == null) { throw new Exception(); } var animals = new List <Alert>(); TableQuery <Alert> query = new TableQuery <Alert>(); //.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "Smith")); TableContinuationToken token = null; do { TableQuerySegment <Alert> resultSegment = await alertsTable.ExecuteQuerySegmentedAsync(query, token); token = resultSegment.ContinuationToken; animals.AddRange(resultSegment.Results); } while (token != null); return(animals); }
public override void ExecuteCommand() { string DeployId = new JavaScriptSerializer().Deserialize <string>(ReportHelpers.Load(StorageAccount, "DeploymentId_" + ServiceName + ".json", ContainerName)); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(PerfCounterTableStorageAccount); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference("WAD" + DeployId + "PT5MRTable"); int count = 0; double sum = 0; TableQuery <dataEntity> rangeQuery = new TableQuery <dataEntity>().Where(TableQuery.CombineFilters( TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThan, DateTime.UtcNow.AddMinutes(-frequencyInMin)), TableOperators.And, TableQuery.GenerateFilterCondition("CounterName", QueryComparisons.Equal, PerfCounterName))); foreach (dataEntity entity in table.ExecuteQuery(rangeQuery)) { count++; sum += entity.Total / entity.Count; } ReportHelpers.AppendDatatoBlob(StorageAccount, ServiceName + PerfCounterName + string.Format("{0:MMdd}", DateTime.Now) + ".json", new Tuple <string, string>(String.Format("{0:HH:mm}", DateTime.Now), (sum / count).ToString("F")), 24 * 60 / frequencyInMin, ContainerName); }
public async Task RemoveOldEntries() { var query = new TableQuery <PlayerLocationEntity>() .Where(TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.LessThan, DateTime.UtcNow.AddHours(-24))); TableContinuationToken continuationToken = null; do { var queryResult = await _locationsTable.ExecuteQuerySegmentedAsync(query, continuationToken); _logger.LogInformation($"Removing {queryResult.Count()} cached entries from the players location repository"); foreach (var entity in queryResult) { var deleteOperation = TableOperation.Delete(entity); await _locationsTable.ExecuteAsync(deleteOperation); } continuationToken = queryResult.ContinuationToken; } while (continuationToken != null); }
async Task <IEnumerable <T> > ReadAllEntitiesAsync <T>(TableQuery <T> query, CloudTable table) where T : ITableEntity, new() { var results = new List <T>(); TableQuerySegment <T> resultSegment = await table.ExecuteQuerySegmentedAsync(query, null); if (resultSegment.Results != null) { results.AddRange(resultSegment.Results); } while (resultSegment.ContinuationToken != null) { resultSegment = await table.ExecuteQuerySegmentedAsync(query, resultSegment.ContinuationToken); if (resultSegment.Results != null) { results.AddRange(resultSegment.Results); } } return(results); }
public PathFinderEvents(string PatientID, string StartDate, string EndDate, string Skill, string StorageConnectionString) { events = new List <PathfinderEvent>(); TableQuery <EventEntity> query = new TableQuery <EventEntity>() .Where( TableQuery.CombineFilters( (TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, PatientID), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, StartDate) )), TableOperators.And, (TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, EndDate), TableOperators.And, TableQuery.GenerateFilterCondition("Skill", QueryComparisons.GreaterThanOrEqual, Skill) )) ) ); ExecuteQuery(query, StorageConnectionString); }
public async Task <List <T> > GetList() { //Table CloudTable table = await GetTableAsync(); //Query TableQuery <T> query = new TableQuery <T>(); List <T> results = new List <T>(); TableContinuationToken continuationToken = null; do { TableQuerySegment <T> queryResults = await table.ExecuteQuerySegmentedAsync(query, continuationToken); continuationToken = queryResults.ContinuationToken; results.AddRange(queryResults.Results); } while (continuationToken != null); return(results); }
public Task <IEnumerable <AzureTableOrchestrationHistoryEventEntity> > ReadOrchestrationHistoryEventsAsync(string instanceId, string executionId) { string partitionKey = AzureTableConstants.InstanceHistoryEventPrefix + AzureTableConstants.JoinDelimiter + instanceId; string rowKeyLower = AzureTableConstants.InstanceHistoryEventRowPrefix + AzureTableConstants.JoinDelimiter + executionId + AzureTableConstants.JoinDelimiter; string rowKeyUpper = AzureTableConstants.InstanceHistoryEventRowPrefix + AzureTableConstants.JoinDelimiter + executionId + AzureTableConstants.JoinDelimiterPlusOne; string filter = string.Format(CultureInfo.InvariantCulture, AzureTableConstants.TableRangeQueryFormat, partitionKey, rowKeyLower, rowKeyUpper); TableQuery <AzureTableOrchestrationHistoryEventEntity> query = new TableQuery <AzureTableOrchestrationHistoryEventEntity>().Where(filter); return(ReadAllEntitiesAsync(query, this.historyTable)); }
// Could be very long public async Task <Segment <IRecentFunctionEntry> > GetRecentFunctionInstancesAsync( RecentFunctionQuery queryParams, string continuationToken) { TableQuery <RecentPerFuncEntity> rangeQuery = RecentPerFuncEntity.GetRecentFunctionsQuery(queryParams); CancellationToken cancellationToken; TableContinuationToken realContinuationToken = Utility.DeserializeToken(continuationToken); var segment = await _instanceTable.SafeExecuteQuerySegmentedAsync <RecentPerFuncEntity>( rangeQuery, realContinuationToken, cancellationToken); if (segment == null) { return(new Segment <IRecentFunctionEntry>(new IRecentFunctionEntry[0])); } else { return(new Segment <IRecentFunctionEntry>(segment.Results.ToArray(), Utility.SerializeToken(segment.ContinuationToken))); } }
public async Task <T> GetSingleAsync(string partitionKey, string rowKey) { string key = string.Format("{0}:{1}:{2}", typeof(T).Name, partitionKey, rowKey); T entity = null; TableQuery <T> query = new TableQuery <T>().Where( TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey))); var tableSet = await table.ExecuteQuerySegmentedAsync(query, null); if (tableSet.Count <T>() >= 1) { entity = tableSet.First(); } return(entity); }
public async Task <IHttpActionResult> GetAllReviewPieces(int exerciseId) { var filterPartition = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, ReviewPiece.GetPartitionKey(exerciseId)); var query = new TableQuery <ReviewPiece>().Where(filterPartition); var allPieces = await AzureStorageUtils.ExecuteQueryAsync(AzureStorageUtils.TableNames.ReviewPieces, query); // Enforce access rights. The exercise author cannot see review items in an unfinished review. An access entity is written when a review is finished. See ReviewsApiController.PostFinishReview var userAccessCode = ReviewPiece.PieceTypes.Viewer + KeyUtils.IntToKey(this.GetUserId()); // Find the ReviewIds which are allowed to access. var reviewIds = allPieces .Where(i => ReviewPiece.GetUserAccessCode(i.RowKey) == userAccessCode) .Select(i => ReviewPiece.GetReviewId(i.RowKey)) .ToList(); RemoveAccessEntries(allPieces); // Filter the record set. var accessablePieces = allPieces.Where(i => reviewIds.Contains(ReviewPiece.GetReviewId(i.RowKey))); var piecesArr = accessablePieces.Select(i => i.Json).ToArray(); return(Ok(piecesArr)); }
public async Task<IEnumerable<Telemetry>> GetLatestTelemetry(string deviceId) { var storageConnectionString = _settings.StorageConnectionString; var table = await AzureTableStorageHelper.GetTableAsync(storageConnectionString, _settings.TelemetryTableName); var startTime = DateTimeOffset.Now.AddSeconds(-TimeOffsetInSeconds).DateTime; var deviceFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId); var timestampFilter = TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThanOrEqual, startTime); var filter = TableQuery.CombineFilters(deviceFilter, TableOperators.And, timestampFilter); TableQuery<TelemetryEntity> query = new TableQuery<TelemetryEntity>() .Where(filter) .Take(MaxRecordsToReceive) .Select(new[] { "sensor11", "sensor14", "sensor15", "sensor9" }); var result = new Collection<Telemetry>(); var entities = table.ExecuteQuery(query) .OrderByDescending(x => x.Timestamp) .Take(MaxRecordsToSend); foreach (var entity in entities) { var telemetry = new Telemetry { DeviceId = entity.PartitionKey, RecordId = entity.RowKey, Timestamp = entity.Timestamp.DateTime, Sensor1 = Math.Round(double.Parse(entity.sensor11)), Sensor2 = Math.Round(double.Parse(entity.sensor14)), Sensor3 = Math.Round(double.Parse(entity.sensor15)), Sensor4 = Math.Round(double.Parse(entity.sensor9)) }; result.Add(telemetry); } return result.OrderBy(x => x.Timestamp); }
public virtual void SetUp() { testTable = Query.Db("test").Table<TestObject>("table"); connection.RunAsync(testTable.Insert(new TestObject[] { new TestObject() { Name = "1", SomeNumber = 1 }, new TestObject() { Name = "1", SomeNumber = 1 }, new TestObject() { Name = "2", SomeNumber = 2 }, new TestObject() { Name = "2", SomeNumber = 200 }, new TestObject() { Name = "2", SomeNumber = 2 }, new TestObject() { Name = "3", SomeNumber = 3 }, new TestObject() { Name = "3", SomeNumber = 3 }, new TestObject() { Name = "4", SomeNumber = 4 }, new TestObject() { Name = "5", SomeNumber = 5 }, new TestObject() { Name = "6", SomeNumber = 6 }, new TestObject() { Name = "6", SomeNumber = 6 }, new TestObject() { Name = "7", SomeNumber = 7 }, })).Wait(); }
public Task<InitialDeviceConfig> GetDeviceAsync(string deviceId) { var query = new TableQuery<DeviceListEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId)); return this.GetDeviceAsync(query); }
async Task<InitialDeviceConfig> GetDeviceAsync(TableQuery<DeviceListEntity> query) { var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName); foreach (var device in devicesTable.ExecuteQuery(query)) { // Always return first device found return new InitialDeviceConfig { DeviceId = device.DeviceId, HostName = device.HostName, Key = device.Key }; } return null; }
public virtual void SetUp() { testTable = Query.Db("test").Table<TestObject>("table"); DoInsert().Wait(); }
public DataResultLogMessageList SearchLogMessages(string LogginConfigurationSectionName, DataFilterLogger dataFilter) { // Pagination Sample over Azute Table Storage Entities // Remember that method "Count" is not supported. Thus, I can't know the total number of pages //using Microsoft.WindowsAzure.Storage.Table.Queryable; //var table = this.TableClient().GetTableReference(dataFilter.LogTraceSourceSelected); //var query = (from log in table.CreateQuery<AzureTableStorageListenerEntity>() // where log.PartitionKey == dataFilter.CreationDateFrom.ToString("yyyyMMdd") // select log).Take(dataFilter.PageSize) // .AsTableQuery<AzureTableStorageListenerEntity>(); //var result = new List<LogMessageModel>(); //var queryResult = query.ExecuteSegmented(dataFilter.NextContinuationToken); //return new DataResultLogMessageList() //{ // Page = dataFilter.Page, // PageSize = dataFilter.PageSize, // Data = queryResult.Results.Select(p => baseModel.DeserializeFromJson<LogMessageModel>(p.LogMessageJSON)).ToList(), // TotalRows = 1000, //-> just a fake // NextContinuationToken = queryResult.ContinuationToken, // PreviousContinuationToken = dataFilter.NextContinuationToken //}; CloudTable table = this.TableClient().GetTableReference(dataFilter.LogTraceSourceSelected); TableQuery<AzureTableStorageListenerEntity> rangeQuery = new TableQuery<AzureTableStorageListenerEntity>().Where( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, dataFilter.CreationDate.ToString("yyyyMMdd")) ); List<AzureTableStorageListenerEntity> resultsList = table.ExecuteQuery<AzureTableStorageListenerEntity>(rangeQuery).ToList(); int rowStartIndex = dataFilter.Page.Value * dataFilter.PageSize; int rowEndIndex = (int)(dataFilter.Page.Value * dataFilter.PageSize) + dataFilter.PageSize; return new DataResultLogMessageList() { Page = dataFilter.Page, PageSize = dataFilter.PageSize, Data = resultsList.Skip(rowStartIndex).Take(dataFilter.PageSize).Select(p => baseModel.DeserializeFromJson<LogMessageModel>(p.LogMessageJSON)).ToList(), TotalRows = resultsList.Count, }; }