public async Task<ActionResult> Search([FromBody] SearchClientsRequest request)
{
if (request == null)
{
return BuildError(ErrorCodes.InvalidRequestCode, "no parameter in body request", HttpStatusCode.BadRequest);
}
var parameter = request.ToSearchClientParameter();
var result = await _clientActions.Search(parameter);
return new OkObjectResult(result.ToDto());
}
public static SearchClientParameter ToSearchClientParameter(this SearchClientsRequest parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
return(new SearchClientParameter
{
ClientIds = parameter.ClientIds,
ClientNames = parameter.ClientNames,
ClientTypes = parameter.ClientTypes,
Count = parameter.NbResults,
StartIndex = parameter.StartIndex,
Order = parameter.Order == null ? null : parameter.Order.ToParameter()
});
}
/// <summary>
/// Search for clients.
/// </summary>
/// <param name="searchClientParameter">The <see cref="SearchClientsRequest"/>.</param>
/// <param name="authorizationHeaderValue">The authorization token.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> for the async operation.</param>
/// <returns></returns>
public Task <Option <PagedResult <Client> > > SearchClients(
SearchClientsRequest searchClientParameter,
string authorizationHeaderValue,
CancellationToken cancellationToken = default)
{
var serializedPostPermission = Serializer.Default.Serialize(searchClientParameter);
var body = new StringContent(serializedPostPermission, Encoding.UTF8, "application/json");
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri(_discoveryInformation.Clients + "/.search"),
Content = body
};
return(GetResult <PagedResult <Client> >(request, authorizationHeaderValue, cancellationToken: cancellationToken));
}
/// <inheritdoc />
public Task <PagedResult <Client> > Search(
SearchClientsRequest newClient,
CancellationToken cancellationToken = default)
{
if (newClient == null)
{
throw new ArgumentNullException(nameof(newClient));
}
IEnumerable <Client> result = _clients;
if (newClient.ClientIds.Any())
{
result = result.Where(c => newClient.ClientIds.Any(i => c.ClientId.Contains(i)));
}
if (newClient.ClientNames.Any())
{
result = result.Where(c => newClient.ClientNames.Any(n => c.ClientName.Contains(n)));
}
if (newClient.ClientTypes.Any())
{
var clientTypes = newClient.ClientTypes.Select(t => t).ToHashSet();
result = result.Where(c => clientTypes.Contains(c.ApplicationType))
.OrderBy(c => c.ClientName);
}
var resultArray = result.ToArray();
var nbResult = resultArray.Length;
if (newClient.NbResults > 0)
{
resultArray = resultArray.Skip(newClient.StartIndex).Take(newClient.NbResults).ToArray();
}
return(Task.FromResult(
new PagedResult <Client>
{
Content = resultArray,
StartIndex = newClient.StartIndex,
TotalResults = nbResult
}));
}
/// <inheritdoc />
public async Task <PagedResult <Client> > Search(
SearchClientsRequest parameter,
CancellationToken cancellationToken = default)
{
await using var session = _sessionFactory();
var take = parameter.NbResults == 0 ? int.MaxValue : parameter.NbResults;
var results = await session.Query <Client>()
.Where(x => x.ClientId.IsOneOf(parameter.ClientIds))
.ToPagedListAsync(parameter.StartIndex + 1, take, cancellationToken)
.ConfigureAwait(false);
return(new PagedResult <Client>
{
Content = results.ToArray(),
StartIndex = parameter.StartIndex,
TotalResults = results.TotalItemCount
});
}
public async Task <PagedResult <ClientResponse> > ExecuteAsync(Uri clientsUri, SearchClientsRequest parameter, string authorizationHeaderValue = null)
{
if (clientsUri == null)
{
throw new ArgumentNullException(nameof(clientsUri));
}
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 = clientsUri,
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 (Exception)
{
var result = new PagedResult <ClientResponse>
{
ContainsError = true,
HttpStatus = httpResult.StatusCode
};
if (!string.IsNullOrWhiteSpace(content))
{
result.Error = JsonConvert.DeserializeObject <ErrorResponseWithState>(content);
}
return(result);
}
return(new PagedResult <ClientResponse>
{
Content = JsonConvert.DeserializeObject <PagedResponse <ClientResponse> >(content)
});
}
public async Task <PagedResult <ClientResponse> > ResolveSearch(Uri wellKnownConfigurationUri, SearchClientsRequest searchClientParameter, string authorizationHeaderValue = null)
{
var configuration = await _configurationClient.GetConfiguration(wellKnownConfigurationUri).ConfigureAwait(false);
return(await _searchClientOperation.ExecuteAsync(new Uri(configuration.Content.ClientsEndpoint + "/.search"), searchClientParameter, authorizationHeaderValue).ConfigureAwait(false));
}
