/// <inheritdoc />
public Task <PagedResult <ResourceOwner> > Search(
SearchResourceOwnersRequest parameter,
CancellationToken cancellationToken = default)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
IEnumerable <ResourceOwner> result = _users;
if (parameter.Subjects != null)
{
result = result.Where(r => parameter.Subjects.Any(s => r.Subject != null && r.Subject.Contains(s)));
}
var nbResult = result.Count();
result = parameter.Descending
? result.OrderByDescending(c => c.UpdateDateTime)
: result.OrderBy(x => x.UpdateDateTime);
if (parameter.NbResults > 0)
{
result = result.Skip(parameter.StartIndex).Take(parameter.NbResults);
}
return(Task.FromResult(
new PagedResult <ResourceOwner>
{
Content = result.ToArray(),
StartIndex = parameter.StartIndex,
TotalResults = nbResult
}));
}
public static SearchResourceOwnerParameter ToParameter(this SearchResourceOwnersRequest request)
{
return(new SearchResourceOwnerParameter
{
Count = request.NbResults,
StartIndex = request.StartIndex,
Subjects = request.Subjects,
Order = request.Order == null ? null : request.Order.ToParameter()
});
}
public async Task <IActionResult> Search([FromBody] SearchResourceOwnersRequest searchResourceOwnersRequest)
{
if (searchResourceOwnersRequest == null)
{
return(BuildError(ErrorCodes.InvalidRequestCode, "no parameter in body request", HttpStatusCode.BadRequest));
}
var result = await _resourceOwnerActions.Search(searchResourceOwnersRequest.ToParameter());
return(new OkObjectResult(result.ToDto()));
}
/// <inheritdoc />
public async Task <PagedResult <ResourceOwner> > Search(
SearchResourceOwnersRequest parameter,
CancellationToken cancellationToken = default)
{
await using var session = _sessionFactory();
var subjects = parameter.Subjects ?? Array.Empty <string>();
var results = await session.Query <ResourceOwner>()
.Where(r => r.Claims.Any(x => x.Type == OpenIdClaimTypes.Subject && x.Value.IsOneOf(subjects)))
.ToPagedListAsync(parameter.StartIndex + 1, parameter.NbResults, cancellationToken)
.ConfigureAwait(false);
return(new PagedResult <ResourceOwner>
{
Content = results.ToArray(),
TotalResults = results.TotalItemCount,
StartIndex = parameter.StartIndex
});
}
public async Task <PagedResult <ResourceOwnerResponse> > ResolveSearch(Uri wellKnownConfigurationUri, SearchResourceOwnersRequest searchResourceOwnersRequest, string authorizationHeaderValue = null)
{
var configuration = await _configurationClient.GetConfiguration(wellKnownConfigurationUri).ConfigureAwait(false);
return(await _searchResourceOwnersOperation.ExecuteAsync(new Uri(configuration.Content.ResourceOwnersEndpoint + "/.search"), searchResourceOwnersRequest, authorizationHeaderValue).ConfigureAwait(false));
}
public async Task <PagedResult <ResourceOwnerResponse> > ExecuteAsync(Uri resourceOwnerUri, SearchResourceOwnersRequest parameter, string authorizationHeaderValue = null)
{
if (resourceOwnerUri == null)
{
throw new ArgumentNullException(nameof(resourceOwnerUri));
}
var httpClient = _httpClientFactory.GetHttpClient();
var serializedPostPermission = JsonConvert.SerializeObject(parameter);
var body = new StringContent(serializedPostPermission, Encoding.UTF8, "application/json");
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = resourceOwnerUri,
Content = body
};
if (!string.IsNullOrWhiteSpace(authorizationHeaderValue))
{
request.Headers.Add("Authorization", "Bearer " + authorizationHeaderValue);
}
var httpResult = await httpClient.SendAsync(request);
var content = await httpResult.Content.ReadAsStringAsync().ConfigureAwait(false);
var rec = JObject.Parse(content);
try
{
httpResult.EnsureSuccessStatusCode();
}
catch
{
var result = new PagedResult <ResourceOwnerResponse>
{
ContainsError = true,
HttpStatus = httpResult.StatusCode
};
if (!string.IsNullOrWhiteSpace(content))
{
result.Error = JsonConvert.DeserializeObject <ErrorResponseWithState>(content);
}
return(result);
}
return(new PagedResult <ResourceOwnerResponse>
{
Content = JsonConvert.DeserializeObject <PagedResponse <ResourceOwnerResponse> >(content)
});
}
