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,
};
}
