public async Task CargarProductoSuperarMaximoTest()
{
Console.WriteLine(_testContext.TestName);
var client = _factory.CreateClient();
MovimientoRequest movimiento = new MovimientoRequest
{
BodegaId = "51ed6452-d6b5-4fa6-a1e4-1e1fbd16d72d",
ProductoId = "ea9acaa9-adaf-45bd-980d-a1bb8ab7abc3",
Cantidad = 100,
Valor = 25000
};
StringContent cuerpo = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(movimiento), Encoding.UTF8, "application/json");
var response = await client.PostAsync("api/Inventario/CargarProducto", cuerpo);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
Assert.AreEqual("application/json; charset=utf-8", response.Content.Headers.ContentType?.ToString());
var result = await response.Content.ReadAsStringAsync();
Resultado <MovimientoDto> resultado = Newtonsoft.Json.JsonConvert.DeserializeObject <Resultado <MovimientoDto> >(result);
Assert.IsNotNull(resultado);
Assert.AreEqual(false, resultado.Correcto);
Assert.IsNull(resultado.Datos);
Assert.AreEqual(1, resultado.Errores.Length);
Assert.AreEqual("La cantidad de producto a ingresar supera el maximo de productos totales permitido en la bodega", resultado.Errores[0]);
}
public async Task CargarProductoTest()
{
Console.WriteLine(_testContext.TestName);
var client = _factory.CreateClient();
MovimientoRequest movimiento = new MovimientoRequest
{
BodegaId = "51ed6452-d6b5-4fa6-a1e4-1e1fbd16d72d",
ProductoId = "ea9acaa9-adaf-45bd-980d-a1bb8ab7abc3",
Cantidad = 10,
Valor = 25000
};
StringContent cuerpo = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(movimiento), Encoding.UTF8, "application/json");
var response = await client.PostAsync("api/Inventario/CargarProducto", cuerpo);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual("application/json; charset=utf-8", response.Content.Headers.ContentType?.ToString());
var result = await response.Content.ReadAsStringAsync();
Resultado <MovimientoDto> resultado = Newtonsoft.Json.JsonConvert.DeserializeObject <Resultado <MovimientoDto> >(result);
Assert.IsNotNull(resultado);
Assert.AreEqual(resultado.Correcto, true);
Assert.IsNotNull(resultado.Datos);
Assert.AreEqual(Guid.Parse("51ed6452-d6b5-4fa6-a1e4-1e1fbd16d72d"), resultado.Datos.Bodega.Id);
Assert.AreEqual(Guid.Parse("ea9acaa9-adaf-45bd-980d-a1bb8ab7abc3"), resultado.Datos.Producto.Id);
Assert.AreEqual(10, resultado.Datos.Cantidad);
Assert.AreEqual(25000, resultado.Datos.Valor);
Assert.AreEqual(TipoMovimiento.Ingreso, resultado.Datos.Tipo);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public async Task <string> RegistroMovimiento(MovimientoRequest request)
{
try
{
Guid _Company = Guid.Empty;
//Antes de llamar al procedimiento realizamos un inserccion en la tabla CajaMovimiento ,
//Esto se hace ya que hay un trigerr en dicha tabla y se debe de lanzar
if (request.uidtipoMovimiento.ToUpper() == "75F161D7-419E-4FD2-BB4C-88F5483752D9")
{
Company_Caja dtoCompany = new Company_Caja();
dtoCompany.UID_Company = Guid.Parse(request.uicompany);
dtoCompany.Fecha = DateTime.Now;
dtoCompany.Importe_Apertura = request.importe;
await _iunitOfWork.CompanyCajaRepository.InsertEntity(dtoCompany);
await _iunitOfWork.CompanyCajaRepository.SaverChangeAsyc();
_Company = dtoCompany.UID;
}
else
{
var companyCaja = _iunitOfWork.CompanyCajaRepository.FindAllAsync(x => x.UID_Company == Guid.Parse(request.uicompany) && x.Fecha <= DateTime.Now).Result.FirstOrDefault();
if (companyCaja != null)
{
_Company = companyCaja.UID;
}
}
if (_Company != Guid.Empty)
{
await _iunitOfWork.CajaMovimientoRepository.InsertEntity(new Company_Caja_Movimientos()
{
Descripcion = request.descripcion,
Importe = request.importe,
UID_TipoMovimiento = Guid.Parse(request.uidtipoMovimiento),
UID_User = Guid.Parse(request.uiperson),
Fecha = DateTime.Now,
UID_Caja = _Company
});
await _iunitOfWork.CajaMovimientoRepository.SaverChangeAsyc();
}
}
catch (CError e)
{
throw _errorManager.AddError("RegistroEvento", "Maestros_RegistroEvento", e, MethodBase.GetCurrentMethod(), null);
}
catch (System.Exception ex)
{
_log.Debug(ex.GetBaseException().ToString());
throw _errorManager.AddError("Error Generico", "Maestros_RegistroEvento", ex, MethodBase.GetCurrentMethod(), null);
}
// return await Task.Run(() => "OK");
return("OK");
}
public void Delete(Movimiento movimiento)
{
try
{
var request = new MovimientoRequest()
{
Movimiento = movimiento
};
HttpPost <MovimientoResponse, MovimientoRequest>("api/Movimiento/Eliminar", request, MediaType.Json);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message);
}
}
public async Task <IActionResult> RegisterMovimiento([FromBody] MovimientoRequest request)
{
try
{
var retonro = await _cajaSrv.RegistroMovimiento(request);
return(Ok(new ApiOkResponse("OK")));
}
catch (CError ce)
{
throw ce;
}
catch (System.Exception ex)
{
throw ex;
}
}
public void Actualizar(MovimientoRequest request)
{
try
{
var bc = new MovimientoComponent();
bc.Edit(request.Movimiento);
}
catch (Exception ex)
{
var httpError = new HttpResponseMessage()
{
StatusCode = (HttpStatusCode)422,
ReasonPhrase = ex.Message
};
throw new HttpResponseException(httpError);
}
}
public async Task <ActionResult <Resultado <MovimientoDto> > > SacarProducto([FromBody] MovimientoRequest movimiento)
{
if (movimiento == null)
{
return(BadRequest(Resultado <MovimientoDto> .Failure("No se encontraron datos para procesar")));
}
var resutlado = await _servicio.SacarProducto(movimiento);
if (resutlado.Correcto)
{
return(Ok(resutlado));
}
else
{
return(BadRequest(resutlado));
}
}
public void Eliminar(MovimientoRequest request)
{
try
{
var bc = new MovimientoComponent();
//var especie = bc.Find(id);
bc.Remove(request.Movimiento);
}
catch (Exception ex)
{
var httpError = new HttpResponseMessage()
{
StatusCode = (HttpStatusCode)422,
ReasonPhrase = ex.Message
};
throw new HttpResponseException(httpError);
}
}
public MovimientoResponse Agregar(MovimientoRequest request)
{
try
{
var response = new MovimientoResponse();
var bc = new MovimientoComponent();
response.Result = bc.Add(request.Movimiento);
return(response);
}
catch (Exception ex)
{
var httpError = new HttpResponseMessage()
{
StatusCode = (HttpStatusCode)422,
ReasonPhrase = ex.Message
};
throw new HttpResponseException(httpError);
}
}
public Movimiento Add(Movimiento movimiento)
{
Movimiento result = default(Movimiento);
try
{
var request = new MovimientoRequest()
{
Movimiento = movimiento
};
var response = HttpPost <MovimientoResponse, MovimientoRequest>("api/Movimiento/Agregar", request, MediaType.Json);
result = response.Result;
}
catch (FaultException fex)
{
throw new ApplicationException(fex.Message);
}
return(result);
}
public static Response <MovimientoResponse> ListarMovimientoCab(MovimientoRequest request)
{
Response <MovimientoResponse> response;
List <MovimientoCabList> lista;
MovimientoCabFilter filtro;
filtro = request.Filtro;
lista = MovimientoCabData.Listar(filtro);
response = new Response <MovimientoResponse>
{
EsCorrecto = true,
Valor = new MovimientoResponse {
Lista = lista
},
Mensaje = "OK"
};
return(response);
}
public async Task <Resultado <MovimientoDto> > CargarProducto(MovimientoRequest movimiento)
{
List <string> errores = new List <string>();
Guid bodegaId;
Guid productoId;
BodegaDto bodega = null;
ProductoDto producto = null;
if (Guid.TryParse(movimiento.BodegaId, out bodegaId))
{
bodega = await _repositorioBodega.BuscarBodega(bodegaId);
if (bodega == null)
{
errores.Add($"La bodega con Id {movimiento.BodegaId} no esta en el sistema");
}
}
else
{
errores.Add("La Id de la bodega no tiene el formato correcto");
}
if (Guid.TryParse(movimiento.ProductoId, out productoId))
{
producto = await _repositorioProducto.BuscarProducto(productoId);
if (producto == null)
{
errores.Add($"El producto con Id {movimiento.ProductoId} no esta en el sistema");
}
}
else
{
errores.Add("La Id del producto no tiene el formato correcto");
}
if (movimiento.Cantidad <= 0)
{
errores.Add("La cantidad debe ser mayor a 0");
}
if (movimiento.Valor <= 0)
{
errores.Add("El valor debe ser mayor a 0");
}
if (errores.Count > 0)
{
return(Resultado <MovimientoDto> .Failure(errores));
}
InventarioDto inventario = await _repositorioInventario.ObtenerInventario(bodega.Id, producto.Id);
int capacidadDisponible = 0;
if (inventario != null)
{
capacidadDisponible = bodega.CapacidadMaxima - inventario.Cantidad;
}
else
{
capacidadDisponible = bodega.CapacidadMaxima;
}
if (movimiento.Cantidad > capacidadDisponible)
{
return(Resultado <MovimientoDto> .Failure("La cantidad de producto a ingresar supera el maximo de productos totales permitido en la bodega"));
}
MovimientoDto movimientoCrear = new MovimientoDto
{
Id = Guid.NewGuid(),
FechaMovimiento = DateTime.Now,
Bodega = bodega,
Producto = producto,
Cantidad = movimiento.Cantidad,
Valor = movimiento.Valor,
Tipo = TipoMovimiento.Ingreso
};
MovimientoDto movimientoCreado = await _repositorioInventario.GuardarMovimiento(movimientoCrear);
if (movimientoCreado != null)
{
await _repositorioInventario.ActualizarInvetario(movimientoCreado);
return(Resultado <MovimientoDto> .Success(movimientoCreado));
}
else
{
errores.Add("Se ha presnetado un problema al guardar el movimiento");
return(Resultado <MovimientoDto> .Failure(errores));
}
}
