public async Task <User> FindBySubjectIdAsync(string subjectId)
{
var user = await _documentDbService.GetDocuments <User>(
$"{FabricIdentityConstants.DocumentTypes.UserDocumentType}{subjectId.ToLower()}");
return(user?.FirstOrDefault());
}
public Task <IEnumerable <IdentityResource> > FindIdentityResourcesByScopeAsync(IEnumerable <string> scopeNames)
{
var identityResources = DocumentDbService
.GetDocuments <IdentityResource>(FabricIdentityConstants.DocumentTypes.IdentityResourceDocumentType)
.Result;
var matchingResources = identityResources.Where(r => scopeNames.Contains(r.Name));
return(Task.FromResult(matchingResources));
}
public Task <IEnumerable <PersistedGrant> > GetAllAsync(string subjectId)
{
var persistedGrants = _documentDbService
.GetDocuments <PersistedGrant>(FabricIdentityConstants.DocumentTypes.PersistedGrantDocumentType).Result;
var matchingGrants =
persistedGrants.Where(p => p.SubjectId.Equals(subjectId, StringComparison.OrdinalIgnoreCase));
return(Task.FromResult(matchingGrants));
}
/// <summary>
/// Delete all jobs and model files associated with a document.
/// </summary>
/// <param name="doc">Document to delete jobs for.</param>
/// <param name="docDbService">IDocDbService.</param>
/// <param name="storageService">IStorageService.</param>
/// <param name="batchService">Azure Batch Service</param>
/// <param name="logger">Logger</param>
/// <returns></returns>
public static async Task DeleteJobsAndResourcesFromDoc(Document doc, IDocumentDbService docDbService, IStorageService storageService, IBatchService batchService, ILogger logger)
{
Contract.Requires(docDbService != null, nameof(docDbService));
Contract.Requires(doc != null, nameof(doc));
var jobs = await docDbService.GetDocuments <BatchJob>((j) => j.DocumentId == doc.Id);
List <Task> taskList = new List <Task>();
foreach (var job in jobs)
{
taskList.Add(DeleteJobAndResources(job, docDbService, storageService, batchService, logger));
}
try
{
await Task.WhenAll(taskList);
}
catch (AggregateException ex)
{
var message = $"Not able to delete {ex.InnerExceptions.Count} of the {taskList.Count} jobs for document {doc.Id}.";
foreach (var e in ex.InnerExceptions)
{
message += $" {e.Message}";
}
throw new BrowseCloudServiceException(message);
}
}
public virtual async Task <IEnumerable <T> > GetAll()
{
var documentType = $"{typeof(T).Name.ToLowerInvariant()}:";
return(await _dbService.GetDocuments <T>(documentType));
}
public async Task <IEnumerable <T> > GetDocuments <T>(string documentType)
{
return(await _innerDocumentDbService.GetDocuments <T>(documentType));
}
public Task <IEnumerable <T> > GetDocuments <T>(string documentKey)
{
return(_innerDocumentDbService.GetDocuments <T>(documentKey));
}
/// <summary>
/// Gets all documents the current user has access to, based on a list of identities.
/// </summary>
/// <param name="idsToSearch">List of identities to search documents for.</param>
/// <param name="documentDbService">IDocumentDbService.</param>
/// <returns></returns>
public static async Task <IEnumerable <Document> > GetAllAccessibleDocuments(IEnumerable <string> idsToSearch, IDocumentDbService documentDbService)
{
Contract.Requires(documentDbService != null, nameof(documentDbService));
return(await documentDbService.GetDocuments <Document>((doc) => idsToSearch.Contains(doc.Owner.Id) || doc.Acl.Any((u) => idsToSearch.Contains(u.Id))));
}
public IEnumerable <Client> GetAllClients()
{
return(_documentDbService.GetDocuments <Client>(FabricIdentityConstants.DocumentTypes.ClientDocumentType)
.Result.ToList());
}
public virtual async Task <IEnumerable <T> > GetAll()
{
return(await DocumentDbService.GetDocuments <T>(DocumentKeyPrefix));
}