private static ICargo Map(CargoDto c)
{
ICargo result;
if (c.Type == "FreshWater")
{
result = new FreshWaterClientSideEntity {
Type = c.Type, Guid = c.Guid
}
}
;
else if (c.Type == "Salt")
{
result = new SaltClientSideEntity {
Type = c.Type, Guid = c.Guid
}
}
;
else if (c.Type == "SaltWater")
{
result = new FreshWaterClientSideEntity {
Type = c.Type, Guid = c.Guid
}
}
;
else
{
throw new Exception($"Unexpected cargo type='{c.Type}'");
}
result.Count = c.Count;
return(result);
}
public async Task Armazenar(CargoDto dto)
{
await ValidarCargoComMesmaDescricao(dto);
if (!NotificacaoDeDominio.HasNotifications())
{
var cargo = new Cargo(dto.Descricao);
if (dto.Id > 0)
{
cargo = await _cargoRepositorio.ObterPorIdAsync(dto.Id);
cargo.AlterarDescricao(dto.Descricao);
}
if (cargo.Validar() && cargo.Id == 0)
{
await _cargoRepositorio.AdicionarAsync(cargo);
}
else
{
await NotificarValidacoesDeDominio(cargo.ValidationResult);
}
}
}
public IList <string> Adicionar(CargoDto obj)
{
mensagens = new List <string>();
var cargo = CargoAdapter.Mapear(obj);
if (!cargo.Validar())
{
mensagens.Add("Cargo invalido");
}
try
{
if (mensagens.Count.Equals(0))
{
_cargoRepository.Adicionar(cargo);
}
}catch (Exception e)
{
mensagens.Add(e.Message);
}
return(mensagens);
}
public ActionResult Add(CargoDto createDto)
{
var json = string.Empty;
string result = "NO";
if (createDto == null)
{
json = JsonEasyUIResult(0, result);
return(Content(json));
}
try
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <CargoDto, CreateUpdateCargoDto>());
var mapper = config.CreateMapper();
var cargo = mapper.Map <CreateUpdateCargoDto>(createDto);
var obj = _cargoAppService.CreateAsync(cargo);
int id = obj.GetAwaiter().GetResult().Id;
if (obj != null)
{
json = JsonEasyUIResult(id, "OK");
}
else
{
json = JsonEasyUIResult(0, result);
}
}
catch (Exception ex)
{
}
return(Content(json));
}
public void DeveNotificarQuandoAtualizarCargoComDescricaoQueJaFoiUtilizada()
{
CargoDto dto = GerarCargoDtoParaAtualizarCargo(_descricaoValida);
Cargo cargo = CargoBuilder.Novo()
.ComId(dto.Id)
.ComDescricao(dto.Descricao)
.Build();
var cargoJaExiste = new List <Cargo> {
CargoBuilder.Novo().ComId(dto.Id).ComDescricao(dto.Descricao).Build(),
CargoBuilder.Novo().ComId(2).ComDescricao(_descricaoValida).Build()
};
_cargoRepositorioMock.Setup(x => x.ObterPorId(dto.Id)).Returns(cargo);
_cargoRepositorioMock.Setup(x => x.ObterPorDescricao(_descricaoValida)).Returns(cargoJaExiste);
_armazenadorDeCargo.Armazenar(dto);
_notificationContextMock.Verify(
x =>
x.AddNotification(TipoDeNotificacao.ErroDeServico, "Descrição utilizada"),
Times.Once
);
}
public async Task <IActionResult> Put(long id, [FromBody] CargoDto cargo)
{
cargo.Id = id;
await _armazenadorDeCargo.Armazenar(cargo);
return(Ok());
}
public async Task <IActionResult> Put(int id, CargoDto cargoDto)
{
cargoDto.Id = id;
await _armazenadorDeCargo.ArmazenarAsync(cargoDto);
return(Ok());
}
public ActionResult Add(CargoDto createDto)
{
var json = string.Empty;
string result = "NO";
if (createDto == null)
{
json = JsonEasyUiResult(0, result);
return(Content(json));
}
try
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <CargoDto, CreateUpdateCargoDto>());
var mapper = config.CreateMapper();
var cargo = mapper.Map <CreateUpdateCargoDto>(createDto);
// TODO: Add logic here
var obj = _cargoAppService.Create(cargo);
int id = obj.GetAwaiter().GetResult().Id;
json = JsonEasyUiResult(id, "OK");
}
catch
{
// ignored
}
return(Content(json));
}
public async Task <CargoDto> AddAsync(CargoDto cargoDto)
{
var cargo = this.mapperCargo.MapperDtoToEntity(cargoDto);
var result = await this.serviceCargo.AddAsync(cargo);
return(this.mapperCargo.MapperEntityToDto(result));
}
public void Armazenar(CargoDto dto)
{
if (dto.Id == 0)
{
var Cargo = new Cargo(dto.Descricao);
if (!Cargo.Validar())
{
_notificationContext.AddNotifications(Cargo.ValidationResult);
return;
}
_cargoRepository.Adicionar(Cargo);
}
else
{
var Cargo = _cargoRepository.ObterPorId(dto.Id);
if (!Cargo.Validar())
{
_notificationContext.AddNotifications(Cargo.ValidationResult);
}
Cargo.AlterarDescricao(dto.Descricao);
_cargoRepository.Atualizar(Cargo);
}
}
private static CargoDto Map(ICargo c)
{
var result = new CargoDto {
Type = c.Type, Guid = c.Guid
};
result.Count = c.Count;
if (c.Type == "FreshWater")
{
//
}
else if (c.Type == "Salt")
{
//
}
else if (c.Type == "SaltWater")
{
//
}
else
{
throw new Exception($"Unexpected cargo type='{c.Type}'");
}
return(result);
}
public async Task <IActionResult> Put(int id, [FromBody] CargoDto dto)
{
dto.Id = id;
servicoDeDominioDeCargos.Atualizar(iMapper.Map <Cargo>(dto));
return(Ok());
}
public CargoDto Armazenar(CargoDto cargoDto)
{
var cargo = new Cargo(cargoDto.Descricao);
_cargoRepository.Alterador(cargo);
cargoDto.Id = cargo.Id;
return(cargoDto);
}
public static Cargo Mapear(CargoDto cargoDto, int cargoId)
{
var cargo = new Cargo(cargoDto.Descricao);
cargo.Id = cargoId;
return(cargo);
}
public async Task DeveNotificarErrosDeDominioQuandoExistir()
{
var cargoDto = new CargoDto();
await _armazenadorDeCargo.Armazenar(cargoDto);
_notificacaoDeDominioMock.Verify(notificacao =>
notificacao.HandleAsync(It.Is <DomainNotification>(d => d.Key == TipoDeNotificacao.ErroDeDominio.ToString())));
}
private async Task ValidarCargoComMesmaDescricao(CargoDto dto)
{
var cargoComMesmaDescricao = await _cargoRepositorio.ObterPorDescricaoAsync(dto.Descricao);
if (cargoComMesmaDescricao != null && cargoComMesmaDescricao.Id != dto.Id)
{
await NotificarValidacaoDeServico(string.Format(CommonResources.MsgDominioComMesmoNomeNoMasculino, CommonResources.CargoDominio));
}
}
public void Destroy(CargoDto cargoDto)
{
var entity = new Cargo();
entity.Id = cargoDto.Id;
entities.Cargos.Attach(entity);
entities.Cargos.Remove(entity);
entities.SaveChanges();
}
public Cargo MapperDtoToEntity(CargoDto cargoDto)
{
var cargo = new Cargo()
{
Id = cargoDto.Id,
Descricao = cargoDto.Descricao
};
return(cargo);
}
public CargoDto MapperEntityToDto(Cargo cargo)
{
var cargoDto = new CargoDto()
{
Id = cargo.Id,
Descricao = cargo.Descricao
};
return(cargoDto);
}
private bool ValidarId(int id, CargoDto cargoDto)
{
if (id != cargoDto.Id)
{
_notificationContext.AddNotification("", Resource.CargoNaoIdentificado);
return(false);
}
return(true);
}
public ActionResult Adicionar(CargoDto cargoDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
mensagens = _cargoService.Adicionar(cargoDto);
return(ValidarRequest("Adicionado com sucesso!"));
}
public ActionResult Atualizar(CargoDto cargoDto, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
mensagens = _cargoService.Atualizar(cargoDto, id);
return(ValidarRequest("Atualizado com sucesso!"));
}
public async Task <IActionResult> Post([FromBody] CargoDto dto)
{
await _armazenadorDeCargo.Armazenar(dto);
if (!OperacaoValida())
{
return(BadRequestResponse());
}
return(Ok(true));
}
public async Task <ActionResult <CargoDto> > Post([FromBody] CargoDto cargoDto)
{
try
{
return(await this.applicationServiceCargo.AddAsync(cargoDto));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <ActionResult <CargoDto> > Put(Guid id, [FromBody] CargoDto cargoDto)
{
try
{
return(await this.applicationServiceCargo.UpdateAsync(id, cargoDto));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task Armazenar(CargoDto cargoDto)
{
if (cargoDto.Id == 0)
{
await NovoCargo(cargoDto);
}
else
{
await EditarCargo(cargoDto);
}
}
public async Task NaoDeveAdicionarUmCargoInvalido()
{
var cargoDto = new CargoDto();
_notificacaoDeDominioMock.Setup(notificacao => notificacao.HasNotifications()).Returns(true);
await _armazenadorDeCargo.Armazenar(cargoDto);
_cargoRepositorioMock.Verify(repositorio =>
repositorio.AdicionarAsync(It.IsAny <Cargo>()), Times.Never());
}
public ArmazenadorDeCargoTests()
{
_faker = FakerBuilder.Novo().Build();
_cargoDto = new CargoDto
{
Descricao = _faker.Lorem.Sentence()
};
_notificacaoDeDominioMock = new Mock <IDomainNotificationHandlerAsync <DomainNotification> >();
_cargoRepositorioMock = new Mock <ICargoRepositorio>();
_armazenadorDeCargo = new ArmazenadorDeCargo(_cargoRepositorioMock.Object, _notificacaoDeDominioMock.Object);
}
public void DeveNotificarQuandoAtualizarUmCargoQueNaoFoiEncontrado()
{
CargoDto dto = GerarCargoDtoParaAtualizarCargo(_descricaoValida);
_armazenadorDeCargo.Armazenar(dto);
_notificationContextMock.Verify(
x =>
x.AddNotification(TipoDeNotificacao.ErroDeServico, "Cargo não encontrado"),
Times.Once
);
}
public void DeveNotificarQuandoAdicionarDescricaoForInvalida(string descricaoInvalida)
{
CargoDto dto = GerarCargoDtoParaAdicionarCargo(descricaoInvalida);
_armazenadorDeCargo.Armazenar(dto);
_notificationContextMock.Verify(
x =>
x.AddNotification(TipoDeNotificacao.ErroDeServico, "Cargo inválido"),
Times.Once
);
}
