public async Task <ResponseResult> AddAsync(IEnumerable <EmployeeRequest> employeesRequest)
{
try
{
var listParticipation = new List <ViewParticipation>();
var operationProfit = _employeeContainer.UnitOfWork.Business.GetAll(_cacheConfig.Value.Key);
if (operationProfit is null)
{
_response.AddNotification(new Notification(nameof(EmployeeApplication),
$"Falha na operação, o valor disponibilizado não pode ser nulo"));
return(_response);
}
await CreateEmployeesAsync(employeesRequest, operationProfit, listParticipation);
FillViewParticipationEmployee(listParticipation, operationProfit);
}
catch (Exception ex)
{
_response.AddNotification(new Notification(nameof(EmployeeApplication),
$"Falha na operação {ex.Message}"));
_employeeContainer.Logger.LogError(default(EventId),
$"Found fails to {nameof(EmployeeApplication)} in AddAsync {ex.Message}");
throw;
}
return(_response);
}
public ResponseResult Add(OperationProfitRequest operationProfitRequest)
{
var _response = new ResponseResult();
try
{
operationProfitRequest.Validate();
if (operationProfitRequest.Notifications.Any())
{
_response.AddNotifications(operationProfitRequest.Notifications);
return(_response);
}
var value = 0.0m;
if (operationProfitRequest.IsValid())
{
value = Convert.ToDecimal(operationProfitRequest.BonusDistribuided.Remove(0, 3));
}
var entidade = new OperationProfit(value);
_unitOfWork.Business.Add(_cacheConfig.Value.Key, entidade);
_response.AddValue(new
{
Status = "Cadastro realizado com sucesso"
});
}
catch (ArgumentNullException ex) {
_response.AddNotification(new Notification(nameof(BusinessApplication), $"Falha na operação {ex.Message}"));
_logger.LogError(default(EventId), $"Found fails to {nameof(BusinessApplication)} in AddAsync{ex.Message} to {nameof(operationProfitRequest)}");
throw;
}
catch (Exception ex)
{
_response.AddNotification(new Notification(nameof(BusinessApplication), $"Falha na operação {ex.Message}"));
_logger.LogError(default(EventId), $"Found fails to {nameof(BusinessApplication)} in AddAsync{ex.Message} to {nameof(operationProfitRequest)}");
throw;
}
return(_response);
}
public async Task <ResponseResult> OperacaoAsync(OperacaoRequest operacao)
{
try
{
operacao.Validate();
if (operacao.Notifications.Any())
{
_response.AddNotifications(operacao.Notifications);
return(_response);
}
var entidade = new Operacao(operacao.IdTransaction, operacao.Valor, operacao.Operacao, operacao.DataHora);
entidade.ObterTransacao();
if (entidade.Notifications.Any())
{
_response.AddNotifications(entidade.Notifications);
return(_response);
}
var transaction = await TransacaoAsync(entidade);
_response.AddValue(new Data
{
Transacao = operacao.Operacao.ToString(),
IdTransacao = operacao.IdTransaction,
Mensagem = $"Operação efutuada com sucesso em :{ operacao.DataHora.ToString()}",
Valor = transaction
});
}
catch (Exception exception)
{
_response.AddNotification(new Notification(nameof(OperacaoService), $"Falha na operação ocorreu uma exceção em :{ exception}"));
}
return(_response);
}
public void ResponseResult_InserirMensagemErro_DeveRetornarStringComMensagens()
{
//arrange
var response = new ResponseResult();
response.AddNotification(new Notification("teste", "teste de erro"));
//Act
var respAsstring = response.ToString();
//Arrange
Assert.Contains("teste de erro", respAsstring);
}
public async Task <ActionResult <ResponseResult> > Refresh([FromBody] RefreshTokenCommand command)
{
var principal = ObterClaimsTokenExpirado(command.Token);
var email = principal.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value;
if (email != command.Email)
{
var responseEmail = new ResponseResult();
responseEmail.AddNotification(new Notification("refresh_token", "email não autorizado"));
return(BadRequest(responseEmail.Fails));
}
var response = await EventBus.SendCommand(command);
if (response.HasFails)
{
return(BadRequest(response.Fails));
}
return(Ok(response.Data));
}
public async Task Invoke(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception ex)
{
var response = new ResponseResult();
response.AddNotification(new Notification("erro interno", (ex.InnerException != null) ? ex.InnerException.Message : ex.Message));
context.Response.StatusCode = 500;
context.Response.ContentType = "application/json";
var result = JsonSerializer.Serialize(
new
{
erros = response.Fails.Select(x => x.Message)
});
await context.Response.WriteAsync(result);
}
}
public async Task <ResponseResult> OperacaoAsync(CriadoOperacaoEvento criadoOperacaoEventos)
{
criadoOperacaoEventos.Validate();
if (criadoOperacaoEventos.Notifications.Any())
{
_response.AddNotifications(criadoOperacaoEventos.Notifications);
return(_response);
}
string payload = $"=> {criadoOperacaoEventos.IdTransacao} Hora => {DateTime.Now}";
try
{
var config = new ProducerConfig
{
BootstrapServers = _options.Value.UrlBase
};
using (var producer = new ProducerBuilder <Null, string>(config).Build())
{
var result = await producer.ProduceAsync(
_options.Value.Topic,
new Message <Null, string>
{
Value = ConvertPedidoToJson(criadoOperacaoEventos)
});
_response.AddValue($"Mensagem: {payload} | " +
$"Status: { result.Status.ToString()}");
}
}
catch (Exception ex)
{
_response.AddNotification(new Flunt.Notifications.Notification("OperacaoProducer", $"Exceção: {ex.GetType().FullName} | " + $"Mensagem: {ex.Message}"));
}
return(_response);
}
