public async Task <ActionResult <ContactViewModel> > EditContact([FromBody] EditContactViewModel model)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(ModelStateErrorResponseError());
}
var editContactCommand = _mapper.Map <EditContactCommand>(model);
var result = await Mediator.SendCommandAsync(editContactCommand);
if (result.Success)
{
await Mediator.NotifyDomainNotification(
DomainNotification.Success($" The contact to {model.ContactName} was edited with success !"));
}
var contact = await _contactRepository.GetContactById(model.ContactId);
var returnModel = _mapper.Map <ContactViewModel>(contact);
return(ResponsePost(
nameof(EditContact),
returnModel));
}
public async Task <ActionResult <ContactViewModel> > DeleteContact(Guid contactId)
{
var contact = await _contactRepository.GetContactById(contactId);
if (contact == null)
{
NotifyError("This contact Id is invalid !");
return(ModelStateErrorResponseError());
}
var deleteContactCommand = _mapper.Map <DeleteContactCommand>(contactId);
var result = await Mediator.SendCommandAsync(deleteContactCommand);
if (result.Success)
{
await Mediator.NotifyDomainNotification(
DomainNotification.Success($" The contact to {contact.ContactName} was excluded with success !"));
}
var returnModel = _mapper.Map <ContactViewModel>(contact);
return(ResponsePost(
nameof(DeleteContact),
returnModel));
}
private void AddErrorsDomain(DomainNotification domainNotification)
{
if (FilledField(domainNotification) && !ThereAreErrors(domainNotification.ErrorMessage))
{
_notifications.Add(domainNotification);
}
}
private async Task NotificarErros(AdicionarItemPedidoCommand command)
{
foreach (var error in command.Validacoes.Errors)
{
var notification = new DomainNotification(command.MessageType, error.ErrorMessage);
await _mediator.Publish(notification, CancellationToken.None);
}
}
public void AddNotification_IsValidTest()
{
var notification = new DomainNotification(_telemetryClient);
notification.AddNotification("400", "Test Notification", sendTelemetry: true);
Assert.True(notification.HasNotifications);
}
public void DomainNotification_DeveAdicionarChaveEValor()
{
var chave = "nome";
var valor = "Nome deve possuir conteúdo";
var domainNotification = new DomainNotification(chave, valor);
domainNotification.Key.Should().Be(chave);
domainNotification.Value.Should().Be(valor);
}
public void AddNotificationMessage_IsValidTest()
{
var notification = new DomainNotification(_telemetryClient);
var notificationMessage = new List <NotificationMessage>
{
new NotificationMessage("400", "Test Notification")
};
notification.AddNotifications(notificationMessage, sendTelemetry: true);
Assert.True(notification.HasNotifications);
}
public void Handler_DeveAdicionarNotificacao()
{
var chave = "nome";
var valor = "Nome deve possuir conteúdo";
var notification = new DomainNotification(chave, valor);
var notificationHandler = new DomainNotificationHandler();
notificationHandler.Handle(notification, CancellationToken.None);
notificationHandler.TemNotificacao().Should().Be(true);
notificationHandler.ObterNotificacoes().Should().HaveCount(1);
var notificacaoLancada = notificationHandler.ObterNotificacoes().First();
notificacaoLancada.Should().NotBeEmpty();
}
public async Task <CommandResponse> Handle(EditContactCommand request, CancellationToken cancellationToken)
{
var contact = await _contactRepository.GetByIdAsync(request.ContactId);
if (contact == null)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail("The Contact is invalid !"));
return(CommandResponse.Fail());
}
var contactType = await _contactTypeRepository.GetByIdAsync(request.ContactTypeId);
if (contactType == null)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail("The Contact Type is invalid !"));
return(CommandResponse.Fail());
}
contact.ChangeName(request.ContactName);
contact.ChangeBirthDate(request.ContactBirthDate);
contact.ChangePhoneNumber(request.ContactPhone);
contact.ChangeContactType(contactType);
if (!contact.IsValid())
{
foreach (var item in contact.ValidationResult.Errors)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail(item.ErrorMessage));
}
return(CommandResponse.Fail("Contact invalid !"));
}
_contactRepository.Update(contact);
var result = await _contactRepository.CommitAsync();
return(result.Success
? CommandResponse.Ok()
: CommandResponse.Fail("Fail recording the register in database !"));
}
public async Task <CommandResponse> Handle(CreateReservationCommand request, CancellationToken cancellationToken)
{
if (!request.ContactId.HasValue)
{
return(CommandResponse.Fail("Contact Invalid"));
}
var contact = await _contactRepository.GetByIdAsync(request.ContactId.Value);
if (contact == null)
{
var contactCreated = CreateContact(request);
if (contactCreated == null)
{
return(CommandResponse.Fail("Contact Invalid"));
}
contact = contactCreated;
}
var reservation = new Reservation(
id: request.ReservationId,
message: request.Message,
contact: contact,
ranking: 1,
favorited: false
);
if (!reservation.IsValid())
{
foreach (var item in reservation.ValidationResult.Errors)
{
DomainNotification.Fail(item.ErrorMessage);
}
return(CommandResponse.Fail("Reservation invalid !"));
}
await _reservationRepository.AddAsync(reservation);
var result = await _reservationRepository.CommitAsync();
return(result.Success
? CommandResponse.Ok()
: CommandResponse.Fail("Fail recording the register in database !"));
}
public DomainNotification MapToDomainNotification()
{
var domainNotification = new DomainNotification(Id.ToString(),
Codigo,
Descricao);
foreach (var solution in Solucoes)
{
domainNotification.AddSolution(solution.Id,
solution.Description,
solution.IDMessage,
solution.UserID,
solution.DateMessage,
solution.Likes);
}
return(domainNotification);
}
public async void AddDomainNotificationError_Ok()
{
var faker = new Faker();
var message = faker.Lorem.Sentence();
var handler = new DomainNotificationHandler();
var domainNotification = DomainNotification.Fail(message);
await handler.Handle(domainNotification, new CancellationToken());
var notifications = handler.GetNotificationsError();
Assert.True(handler.HasNotificationsError());
Assert.True(notifications.Count == 1);
}
private Usuario CriarUsuario(UsuarioRegistrarViewModel usuarioRegistrarViewModel)
{
var nomeCompleto = new Nome(usuarioRegistrarViewModel.Nome);
var banco = _bancoRepositorio.ObterPorId(usuarioRegistrarViewModel.BancoId);
if (banco == null)
{
DomainNotification.CriarNotificacao("BancoNaoEncontrado", "Não foi possível localizar o banco informado.");
return(null);
}
var saldo = new Saldo(usuarioRegistrarViewModel.SaldoInicial);
var conta = new Conta(banco, saldo);
var usuario = new Usuario(nomeCompleto, conta);
return(usuario);
}
public async void GetNotificationsError_Ok()
{
var faker = new Faker();
var message = faker.Lorem.Sentence();
var handler = new DomainNotificationHandler();
var domainNotification = DomainNotification.Fail(message);
await handler.Handle(domainNotification, new CancellationToken());
var notifications = handler.GetNotificationsError();
var result = notifications.Select(x => x.Value);
Assert.Contains(message, result);
}
