public async Task <IActionResult> GetOne(
[FromBody] GetOneRequest request,
CancellationToken token)
{
var query = new GetOneQuery(
request.AccountNumber,
CorrelationContext.Get());
var response = await _mediator
.Send(
query,
token);
if (!response
.ValidationResult
.IsValid)
{
var errors = string.Empty;
response
.ValidationResult
.Errors
.ToList()
.ForEach(e => { errors += $"{e}//r//n"; });
return(BadRequest(errors));
}
return(Ok(new GetOneView(
response.AccountName,
response.AccountNumber,
response.Balance)));
}
/// <inheritdoc />
public override Task <GetOneResponse> GetOne(GetOneRequest request, ServerCallContext context)
{
var response = new GetOneResponse();
var getIds = GetEventHandlerId(request.ScopeId, request.EventHandlerId, out var eventHandler);
if (!getIds.Success)
{
response.Failure = _exceptionToFailureConverter.ToFailure(getIds.Exception);
return(Task.FromResult(response));
}
Log.GetOne(_logger, eventHandler.EventHandler, eventHandler.Scope);
var info = _eventHandlers.All.FirstOrDefault(_ => _.Id == eventHandler);
if (info == default)
{
Log.EventHandlerNotRegistered(_logger, eventHandler.EventHandler, eventHandler.Scope);
response.Failure = _exceptionToFailureConverter.ToFailure(new EventHandlerNotRegistered(eventHandler));
return(Task.FromResult(response));
}
response.EventHandlers = CreateStatusFromInfo(info, request.TenantId?.ToGuid());
return(Task.FromResult(response));
}
public async Task <IActionResult> GetOne(GetOneRequest request)
{
var getOneResult = await _projectionsService.TryGetOne(
request.Projection,
request.Scope,
request.Key,
request.Context.ExecutionContext.ToExecutionContext(),
System.Threading.CancellationToken.None).ConfigureAwait(false);
if (getOneResult.Success)
{
return(Ok(GetOneResponse.From(getOneResult.Result)));
}
Response.StatusCode = StatusCodes.Status500InternalServerError;
return(new JsonResult(GetOneResponse.From(getOneResult.Exception.ToFailure())));
}
/// <inheritdoc />
public async Task <Try <AggregateRootWithTenantScopedInstances> > Get(MicroserviceAddress runtime, ArtifactId aggregateRootId, TenantId tenant = null)
{
var client = _clients.CreateClientFor <AggregateRootsClient>(runtime);
var request = new GetOneRequest()
{
TenantId = tenant?.ToProtobuf(),
AggregateRootId = aggregateRootId.ToProtobuf()
};
var response = await client.GetOneAsync(request);
if (response.Failure is not null)
{
return(new GetOneFailed(response.Failure.Reason));
}
return(FromProtobuf(response.AggregateRoot));
}
/// <inheritdoc />
public async Task <Try <EventHandlerStatus> > Get(MicroserviceAddress runtime, EventHandlerId eventHandler, TenantId tenant = null)
{
var client = _clients.CreateClientFor <EventHandlersClient>(runtime);
var request = new GetOneRequest
{
EventHandlerId = eventHandler.EventHandler.ToProtobuf(),
ScopeId = eventHandler.Scope.ToProtobuf(),
TenantId = tenant?.ToProtobuf()
};
var response = await client.GetOneAsync(request);
if (response.Failure != null)
{
throw new GetOneEventHandlerFailed(eventHandler, response.Failure.Reason);
}
return(CreateEventHandlerStatus(response.EventHandlers));
}
/// <inheritdoc />
public override async Task <GetOneResponse> GetOne(GetOneRequest request, ServerCallContext context)
{
try
{
_logger.GetOneAggregateRoot(request.AggregateRootId.ToGuid());
var tenant = request.TenantId?.ToGuid();
var aggregatesRoot = tenant is null
? await _tenantScopedAggregateRoot.GetAggregateRootForAllTenants(request.AggregateRootId.ToGuid()).ConfigureAwait(false)
: await _tenantScopedAggregateRoot.GetAggregateRootFor(tenant, request.AggregateRootId.ToGuid()).ConfigureAwait(false);
return(new GetOneResponse {
AggregateRoot = ToProtobuf(aggregatesRoot)
});
}
catch (Exception ex)
{
_logger.Failure(ex);
return(new GetOneResponse {
Failure = ex.ToProtobuf()
});
}
}
/// <inheritdoc/>
public override async Task <GetOneResponse> GetOne(GetOneRequest request, ServerCallContext context)
{
var response = new GetOneResponse();
var getOneResult = await _projectionsService.TryGetOne(
request.ProjectionId.ToGuid(),
request.ScopeId.ToGuid(),
request.Key,
request.CallContext.ExecutionContext.ToExecutionContext(),
context.CancellationToken).ConfigureAwait(false);
if (getOneResult.Success)
{
response.State = getOneResult.Result.ToProtobuf();
Log.SendingGetOneResult(_logger, request.Key, request.ProjectionId, request.ScopeId, getOneResult.Result.Type);
}
else
{
response.Failure = getOneResult.Exception.ToFailure();
Log.SendingGetOneFailed(_logger, request.Key, request.ProjectionId, request.ScopeId, getOneResult.Exception);
}
return(response);
}
