public async Task GetLimitrofesPaisAsync_DevuelveArrayVacio_SiNoTieneLimitrofes()
{
// preparo
var limitrofesEsperados = new PaisDto[0];
var mockPaisesApi = new Mock <IApiPaises>();
mockPaisesApi
.Setup(api => api.BuscarPaisesPorCodigoAsync(new string[] { "NZL" }))
.ReturnsAsync(new PaisDto[] { _paisesDePrueba["NZL"] })
.Verifiable();
var mockLogger = new Mock <ILogger <PaisController> >();
// ejecuto
var controller = new PaisController(mockPaisesApi.Object, mockLogger.Object);
var respuesta = await controller.GetLimitrofesPaisAsync("NZL");
// valido
Assert.NotNull(respuesta);
var resultadoApi = respuesta.Result;
var datosResultado = respuesta.Value;
Assert.Null(resultadoApi);
Assert.NotNull(datosResultado);
Assert.Equal(0, datosResultado.Count());
mockPaisesApi.Verify();
}
public async Task <IActionResult> Put(long id, [FromBody] PaisDto valueDto)
{
var result = new ResultDto <bool>();
try
{
var modelExists = await _paisService.GetByIdAsync(id);
if (modelExists == null)
{
throw new AwayException("No existe el registro que desea editar.");
}
valueDto.Id = modelExists.Id;
result.Data = await _paisService.UpdateAsync(valueDto);
}
catch (AwayException ex)
{
_logger.Error(KOriginApp, ex.Message, ex);
result.AddError(ex.Message);
}
catch (Exception ex)
{
_logger.Error(KOriginApp, ex.Message, ex);
result.AddError("Ocurrió un error al intentar editar los datos del registro.");
}
return(Ok(result));
}
public IActionResult Create([Bind] PaisDto pais)
{
if (ModelState.IsValid)
{
_baseBll.Insert(pais);
return(RedirectToAction("Index"));
}
return(View());
}
public void Modificar(PaisDto pais)
{
_paisRepositorio.Update(new Dominio.Entity.Entidades.Pais()
{
Descripcion = pais.Descripcion,
FileName = pais.FileName,
Path = pais.Path,
RowVersion = pais.RowVersion
});
_paisRepositorio.Save();
}
public bool AddNew(PaisDto pais)
{
List <PaisDto> listaPais = this.GetAll();
if (listaPais != null && listaPais.FirstOrDefault(x => x.Nombre.Trim().ToLower() == pais.Nombre.Trim().ToLower()) != null)
{
return(false);
}
pais.Id = this.GetNextId();
Save(pais);
return(true);
}
public static PaisModel MapearPaisParaModel(this PaisDto dto)
{
if (dto == null)
{
return(null);
}
return(new PaisModel()
{
CodigoArea = dto.CodigoArea,
Pais = dto.Pais,
Sigla = dto.Sigla
});
}
public bool Modify(PaisDto pais)
{
List <PaisDto> listaPais = this.GetAll();
if (pais != null && listaPais.FirstOrDefault(x => x.Id == pais.Id) != null)
{
listaPais.FirstOrDefault(x => x.Id == pais.Id).Nombre = pais.Nombre;
File.Delete(_path);
this.Save(listaPais);
return(true);
}
return(false);
}
public async Task <IActionResult> Delete(PaisDto dto)
{
var result = new HttpResult <PaisDto>(this._logger, this._service);
try
{
await this._service.Remove(dto);
return(result.ReturnCustomResponse(dto));
}
catch (Exception ex)
{
return(result.ReturnCustomException(ex, "Pais", dto));
}
}
public async Task <IActionResult> Post([FromBody] PaisDto valueDto)
{
var result = new ResultDto <PaisDto>();
try
{
result.Data = await _paisService.CreateAsync(valueDto);
}
catch (Exception ex)
{
_logger.Error(KOriginApp, ex.Message, ex);
result.AddError("Ocurrió un error al intentar agregar el registro.");
}
return(Ok(result));
}
public PaisDto Add(PaisDto dto)
{
var obj = new Domain.Entity.Entity.Pais()
{
Descripcion = dto.Descripcion,
Eliminado = dto.Eliminado
};
_paisRepository.Add(obj);
Save();
dto.Id = obj.Id;
return(dto);
}
public async Task <IActionResult> Create(PaisDto dto)
{
// mapeamos el dto al tipo Pais
var pais = _mapper.Map <Pais>(dto);
// guardamos
await _context.Paises.AddAsync(pais);
await _context.SaveChangesAsync();
// mapeamos a su tipo dto para retornar
var dtoToReturn = _mapper.Map <PaisDetailDto>(pais);
return(CreatedAtAction("Detail", new { Id = pais.Id }, dtoToReturn));
}
public IActionResult Edit([Bind] PaisDto dto)
{
if (ModelState.IsValid)
{
try
{
_baseBll.Edit(dto);
return(Ok());
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
return(StatusCode(StatusCodes.Status428PreconditionRequired));
}
public async Task <IActionResult> Update(long id, PaisDto dto)
{
// chequeamos si existe el Pais
var pais = await _context.Paises.SingleOrDefaultAsync(p => p.Id == id);
if (pais == null)
{
return(NotFound());
}
// mapeamos el dto al tipo Pais
pais = _mapper.Map <PaisDto, Pais>(dto, pais);
// actualizamos
await _context.SaveChangesAsync();
return(NoContent());
}
public PaisDto Update(PaisDto dto)
{
var obj = _paisRepository.GetById(dto.Id);
if (obj != null)
{
obj.Descripcion = dto.Descripcion;
_paisRepository.Update(obj);
Save();
return(dto);
}
else
{
return(null);
}
}
internal override DtoBase PopulateDto(OracleDataReader reader)
{
var pais = new PaisDto();
//
if (!reader.IsDBNull(_ordPasId))
{
pais.PasId = reader.GetInt32(_ordPasId);
}
//
if (!reader.IsDBNull(_ordPasDescripcion))
{
pais.PasDescripcion = reader.GetString(_ordPasDescripcion);
}
// IsNew
pais.IsNew = false;
return(pais);
}
public void Save(PaisDto pais)
{
string json = JsonConvert.SerializeObject(pais);
if (File.Exists(_path))
{
using (var writer = new StreamWriter(_path, true))
{
writer.WriteLine(json);
writer.Close();
}
}
else
{
File.WriteAllText(_path, json);
using (var writer = new StreamWriter(_path, true))
{
writer.WriteLine(string.Empty);
writer.Close();
}
}
}
public async Task GetLimitrofesPaisAsync_DevuelveArrayDeLimitrofesOrdenPoblacDesc_SiTieneLimitrofes(string codPais3)
{
// preparo
var limitrofesEsperados = new PaisDto[] { _paisesDePrueba["URY"], _paisesDePrueba["BRA"], _paisesDePrueba["BOL"], _paisesDePrueba["CHL"] };
var mockPaisesApi = new Mock <IApiPaises>();
mockPaisesApi
.Setup(api => api.BuscarPaisesPorCodigoAsync(new string[] { codPais3.Trim().ToUpper() }))
.ReturnsAsync(new PaisDto[] { _paisesDePrueba[codPais3.Trim().ToUpper()] })
.Verifiable();
mockPaisesApi
.Setup(api => api.BuscarPaisesPorCodigoAsync(_paisesDePrueba[codPais3.Trim().ToUpper()].CodigoLimitrofes))
.ReturnsAsync(limitrofesEsperados)
.Verifiable();
var mockLogger = new Mock <ILogger <PaisController> >();
// ejecuto
var controller = new PaisController(mockPaisesApi.Object, mockLogger.Object);
var respuesta = await controller.GetLimitrofesPaisAsync(codPais3);
// valido
Assert.NotNull(respuesta);
var resultadoApi = respuesta.Result;
var datosResultado = respuesta.Value;
Assert.Null(resultadoApi);
Assert.NotNull(datosResultado);
var ordenEsperado = "BRA,CHL,BOL,URY";
Assert.Equal(ordenEsperado, string.Join(",", datosResultado.Select(x => x.Codigo3)));
mockPaisesApi.Verify();
}
public async Task <IActionResult> Create(PaisViewModel vm)
{
try
{
if (!ModelState.IsValid)
{
throw new Exception("Error de validacion no controlado");
}
var paisDto = new PaisDto()
{
Nombre = vm.Nombre,
};
await _paisServicio.Insertar(paisDto);
return(RedirectToAction(nameof(Index)));
}
catch (Exception)
{
return(View(vm));
}
}
public void Modify(PaisDto pais)
{
_service.Modify(pais);
}
public int Save([FromBody] PaisDto pais)
{
_service.AddNew(pais);
return(pais.Id);
}
public async Task <bool> Actualizar(PaisDto dto)
{
return(await _repositorio.Actualizar(_mapper.Map <PaisDto, Pais>(dto)));
}
public async Task <PaisDto> Consultar(PaisDto dto)
{
throw new NotImplementedException();
}
public async Task <PaisDto> Registrar(PaisDto dto)
{
var response = await _repositorio.Agregar(_mapper.Map <PaisDto, Pais>(dto));
return(_mapper.Map <Pais, PaisDto>(response));
}
public async Task <bool> Actualizar(PaisDto dto)
{
return(await _servicio.Actualizar(dto));
}
public async Task <ActionResult> Registrar(PaisDto dto)
{
var response = await _servicio.Registrar(dto);
return(Ok(response));
}
