public async Task <IList <string> > GetRolesAsync(TUser user, CancellationToken cancellationToken)
{
TableQuerySegment Segment = await _db.RoleData.ExecuteQuerySegmentedAsync(new TableQuery().Where($"PartitionKey eq 'UserRole_{user.RowKey}'"), null);
//if (Segment.Count() > 0) { IList<string> x = Segment.Select(role => role.RowKey).ToList(); }
return(Segment.Count() > 0 ? Segment.Select(role => role.RowKey).ToList() : null);
}
async Task <IList <TResult> > ExecuteQueryAsync <TQuery, TResult>(CloudTable table, TableQuery <TQuery> query,
Func <TQuery, TResult> selector)
where TQuery : class, ITableEntity, new()
{
var results = new List <TResult>();
TableContinuationToken token = null;
var options = new TableRequestOptions();
var context = new OperationContext
{
ClientRequestID = Guid.NewGuid().ToString(),
};
do
{
TableQuerySegment <TQuery> result =
await table.ExecuteQuerySegmentedAsync(query, token, options, context, default(CancellationToken));
results.AddRange(result.Select(selector));
token = result.ContinuationToken;
}while (token != null);
return(results);
}
public async Task <List <String> > GetEmpresasAsync()
{
TableQuery <Cliente> query = new TableQuery <Cliente>();
TableQuerySegment <Cliente> segments = await this.table.ExecuteQuerySegmentedAsync(query, null);
return(segments.Select(x => x.Empresa).Distinct().ToList());
}
public static async Task <IEnumerable <TResult> > ExecuteQueryAsync <TQuery, TResult>(this CloudTable table, TableQuery <TQuery> query,
Func <TQuery, TResult> selector, CancellationToken cancellationToken = default(CancellationToken))
where TQuery : class, ITableEntity, new()
{
try
{
var results = new List <TResult>();
TableContinuationToken token = null;
var options = new TableRequestOptions();
var context = new OperationContext
{
ClientRequestID = Guid.NewGuid().ToString(),
};
do
{
TableQuerySegment <TQuery> result = await table.ExecuteQuerySegmentedAsync(query, token, options, context, cancellationToken);
results.AddRange(result.Select(selector));
token = result.ContinuationToken;
}while (token != null);
return(results);
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
throw;
}
}
public async Task <IEnumerable <string> > GetNames()
{
try
{
var query = new TableQuery <RotaTypeNameDto>();
TableQuerySegment <RotaTypeNameDto> results = await _table.ExecuteQuerySegmentedAsync(query, null);
return(results.Select(rn => rn.Name).Distinct());
}
catch (Exception e)
{
throw new Exception($"Could not get all names on rotas", e);
}
}
public async Task <IEnumerable <string> > GetNames(string rotaType)
{
try
{
var typeFilter = TableQuery.GenerateFilterCondition("RotaType", QueryComparisons.Equal, rotaType);
TableQuery <RotaTypeNameDto> query = new TableQuery <RotaTypeNameDto>().Where(typeFilter);
TableQuerySegment <RotaTypeNameDto> results = await _table.ExecuteQuerySegmentedAsync(query, null);
return(results.Select(rn => rn.Name));
}
catch (Exception e)
{
throw new Exception($"Could not get people on: {rotaType}.", e);
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[Table("Collections")] CloudTable collectionsTable, ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
TableQuery <CollectionsTableEntity> query = new TableQuery <CollectionsTableEntity>();
TableQuerySegment <CollectionsTableEntity> segment = await collectionsTable.ExecuteQuerySegmentedAsync(query, null);
List <CollectionsTableEntity> tablelist = segment.ToList();
log.LogInformation("Counted: " + tablelist.Count());
// transform the objects returned so they only have the relevant fields
// TODO: error condition
return((ActionResult) new OkObjectResult(segment.Select(Mappings.ToPinItem)));
}
public async Task PublishAllEvents(CancellationToken cancellationToken)
{
var query = new TableQuery <PendingEventTableEntity>();
var filter = PendingEventTableEntity.ScanFilter;
TableContinuationToken continuation = null;
do
{
TableQuerySegment <PendingEventTableEntity> segment = await _eventTable
.ExecuteQuerySegmentedAsync(query.Where(filter), continuation, cancellationToken)
.ConfigureAwait(false);
foreach (string partition in segment.Select(e => e.PartitionKey).Distinct())
{
await Publish(partition, cancellationToken).ConfigureAwait(false);
}
continuation = segment.ContinuationToken;
}while (continuation != null);
}
public async Task FlushAllPendingEvents(CancellationToken cancellationToken)
{
string filter = PendingEvent.FullScanFilter;
var query = new TableQuery <PendingEvent> {
FilterString = filter
};
TableContinuationToken continuation = null;
do
{
TableQuerySegment <PendingEvent> segment = await _eventTable
.ExecuteQuerySegmented(query, continuation, cancellationToken)
.ConfigureAwait(false);
foreach (string partition in segment.Select(e => e.PartitionKey).Distinct())
{
await Flush(partition, cancellationToken).ConfigureAwait(false);
}
continuation = segment.ContinuationToken;
}while (continuation != null);
}
public async Task <IList <Claim> > GetClaimsAsync(TUser user, CancellationToken cancellationToken)
{
TableQuerySegment <TUserClaim> Segment = await _db.UserClaimData.ExecuteQuerySegmentedAsync(new TableQuery <TUserClaim>().Where($"PartitionKey eq '{user.Id}'"), null);
return(Segment.Count() > 0 ? Segment.Select(uc => uc.ToClaim()).ToList() : null);
}
public async Task <IList <UserLoginInfo> > GetLoginsAsync(TUser user, CancellationToken cancellationToken)
{
TableQuerySegment <TUserLogin> Segment = await _db.UserLoginData.ExecuteQuerySegmentedAsync(new TableQuery <TUserLogin>().Where($"UserId eq '{user.Id}'"), null);
return(Segment.Count() > 0 ? Segment.Select(ul => new UserLoginInfo(ul.LoginProvider, ul.ProviderKey, ul.ProviderDisplayName)).ToList() : null);
}
public IEnumerator <T> GetEnumerator()
{
return(_segment.Select(_parent.ConvertResult).GetEnumerator());
}