public void ActualizarItemTestMethod_Ok()
{
#region Arrange
InventarioItem item = new InventarioItem()
{
Id = Guid.NewGuid(), Nombre = "item2", Unidades = 500, IsNotificacionExpiradaEnviada = true, FechaCaducidad = DateTime.Today.AddDays(-5)
};
IInventarioItemService service = CreateInventarioService();
_inventarioItemRepositoryMocked.Setup(s => s.Update(It.IsAny <InventarioItem>())).Verifiable();
_inventarioItemRepositoryMocked.Setup(s => s.UnitOfWork).Returns(It.IsAny <IUnitOfWork>());
_ = _inventarioItemRepositoryMocked.Setup(s => s.UnitOfWork.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));
#endregion
#region Act
var actual = service.ActualizarItem(item).GetAwaiter().GetResult();
#endregion
#region Assert
Assert.IsTrue(actual);
_inventarioItemRepositoryMocked.Verify(s => s.Update(It.IsAny <InventarioItem>()), Times.Once);
#endregion
}
public async Task UpdateAsync(InventarioItem obj)
{
bool TemAlgum = await _context.InventarioItem.AnyAsync(x => x.Id == obj.Id);
if (!TemAlgum)
{
throw new NotFoundException("Id não encontrado!");
}
try
{
obj.DataAlteracao = DateTime.Now;
obj.Usuario = _user.Name;
_context.Update(obj);
await _context.SaveChangesAsync();
await Auditoria(obj.Inventario.CentroDeCusto.EmpresaId,
Modulo.Estoque,
SubModulo.Inventario,
Operacao.Alteracao,
"TODO");
}
catch (DbUpdateConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
public async Task <bool> SacarItem(InventarioItem item)
{
if (item == null || item.Id == Guid.Empty)
{
throw new KeyNotFoundException();
}
try
{
await Task.Run(() => _inventarioRepository.Delete(item));
int result = await _inventarioRepository.UnitOfWork.SaveChangesAsync();
// Controlo si el resultado de borrado es satisfactorio.
//Evitaría mandar más de un mensaje en casos de llamadas concurrentes
if (result == 1)
{
// mandar vento a todos los clientes de elemento eliminado
await _hub.Clients.All.SendCoreAsync("ReceiveDeletedMessage", new object[] { new DeletedMessageReceived()
{
Id = item.Id, Name = item.Nombre
} });
}
//_deletedEventHandler.Publish(new DeletedMessageReceived() { Id = item.Id, Name = item.Nombre });
return(true);
}
catch (Exception ex)
{
_logger.LogError($"Se ha producido un error sacando un elemento. Item: {JsonConvert.SerializeObject(item)}");
throw ex;
}
}
public ActionResult AltaEliminar(int id = 0, int movimientoID = 0)
{
InventarioItem InventarioItem = db.InventarioItem.Find(id);
db.InventarioItem.Remove(InventarioItem);
db.SaveChanges();
return(RedirectToAction("Alta", "Inventario", new { movimientoID = movimientoID, id = 0 }));
}
public async Task InsertAsync(InventarioItem obj)
{
obj.Usuario = _user.Name;
_context.Add(obj);
await _context.SaveChangesAsync();
await Auditoria(obj.Inventario.CentroDeCusto.EmpresaId,
Modulo.Estoque,
SubModulo.Inventario,
Operacao.Inclusao,
"TODO");
}
public async Task <IActionResult> Create(InventarioItem inventarioItem, int inventarioId)
{
var inventario = await _inventarioService.FindByIdAsync(EmpresaId, inventarioId);
inventarioItem.Inventario = inventario;
InventarioItem item = await _inventarioItemService.FindByProdutoIdAsync(EmpresaId, inventarioId, int.Parse(inventarioItem.ProdutoId.ToString()));
Produto produto = await _produtoService.FindByIdAsync(EmpresaId, int.Parse(inventarioItem.ProdutoId.ToString()));
if (item is null)
{
inventarioItem.InventarioId = inventarioId;
inventarioItem.PrecoCompra = produto.PrecoCompra;
inventarioItem.PrecoCusto = produto.PrecoCusto;
inventarioItem.PrecoVenda = produto.PrecoVenda;
await _inventarioItemService.InsertAsync(inventarioItem);
}
else
{
item.QuantidadeInformada = inventarioItem.QuantidadeInformada + item.QuantidadeInformada;
item.PrecoCompra = produto.PrecoCompra;
item.PrecoCusto = produto.PrecoCusto;
item.PrecoVenda = produto.PrecoVenda;
if (item.QuantidadeInformada == 0)
{
await _inventarioItemService.RemoveAsync(item.Id);
}
else
{
await _inventarioItemService.UpdateAsync(item);
}
}
var inventarioItens = await _inventarioItemService.FindByInventarioIdAsync(EmpresaId, inventarioId);
var produtos = await _produtoService.FindAllAsync(EmpresaId);
var viewModel = new InventarioItensFormViewModel
{
Inventario = inventario,
InventarioItens = inventarioItens,
Produtos = produtos
};
return(View(viewModel));
}
public void ActualizarItemNullTestMethod_Exception()
{
#region Arrange
InventarioItem item = null;
IInventarioItemService service = CreateInventarioService();
_inventarioItemRepositoryMocked.Setup(s => s.Update(It.IsAny <InventarioItem>())).Verifiable();
_inventarioItemRepositoryMocked.Setup(s => s.UnitOfWork).Returns(It.IsAny <IUnitOfWork>());
_ = _inventarioItemRepositoryMocked.Setup(s => s.UnitOfWork.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));
#endregion
#region Act
var actual = service.ActualizarItem(item).GetAwaiter().GetResult();
#endregion
}
public async Task <bool> ActualizarItem(InventarioItem item)
{
if (item == null || item.Id == Guid.Empty)
{
throw new KeyNotFoundException();
}
try
{
_inventarioRepository.Update(item);
await _inventarioRepository.UnitOfWork.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
_logger.LogError($"Se ha producido un error actualizando un elemento. item: {JsonConvert.SerializeObject(item)}");
throw ex;
}
}
public async Task <InventarioItem> InsertarItem(InventarioItem item)
{
if (item == null || item.Id == Guid.Empty)
{
throw new KeyNotFoundException();
}
try
{
await Task.Run(() => _inventarioRepository.Add(item));
await _inventarioRepository.UnitOfWork.SaveChangesAsync();
return(item);
}
catch (Exception ex)
{
_logger.LogError($"Se ha producido un error insertando un elemento. Item: {JsonConvert.SerializeObject(item)}");
throw ex;
}
}
public void SacarItemEmptyPrimaryKeyTestMethod_Exception()
{
#region Arrange
InventarioItem item = new InventarioItem()
{
Id = new Guid()
};
IInventarioItemService service = CreateInventarioService();
_inventarioItemRepositoryMocked.Setup(s => s.Add(It.IsAny <InventarioItem>())).Verifiable();
_inventarioItemRepositoryMocked.Setup(s => s.UnitOfWork).Returns(It.IsAny <IUnitOfWork>());
_ = _inventarioItemRepositoryMocked.Setup(s => s.UnitOfWork.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));
#endregion
#region Act
var actual = service.SacarItem(item).GetAwaiter().GetResult();
#endregion
}
public void InsertItemSaveChangesErrorMethod_Exception()
{
#region Arrange
InventarioItem item = new InventarioItem()
{
Id = Guid.NewGuid(), Nombre = "item2", Unidades = 500, IsNotificacionExpiradaEnviada = true, FechaCaducidad = DateTime.Today.AddDays(-5)
};
IInventarioItemService service = CreateInventarioService();
_inventarioItemRepositoryMocked.Setup(s => s.Add(It.IsAny <InventarioItem>())).Verifiable();
_inventarioItemRepositoryMocked.Setup(s => s.UnitOfWork).Returns(It.IsAny <IUnitOfWork>());
_ = _inventarioItemRepositoryMocked.Setup(s => s.UnitOfWork.SaveChangesAsync(It.IsAny <CancellationToken>())).Throws <Exception>();
#endregion
#region Act
var actual = service.InsertarItem(item).GetAwaiter().GetResult();
#endregion
}
public ViewResult Baja(int id = 0, int movimientoID = 0)
{
Proyecto Proyecto = (Proyecto)Session["Proyecto"];
if (movimientoID > 0)
{
ViewBag.Listado = db.InventarioBaja.Where(i => i.MovimientoID == movimientoID).OrderBy(i => i.Item.Especie.Nombre).ToList();
ViewBag.MovimientoID = movimientoID;
}
else
{
ViewBag.MovimientoID = 0;
}
InventarioItem item = new InventarioItem();
if (id > 0)
{
item = db.InventarioItem.Find(id);
ViewBag.ID = id;
ViewBag.EspecieID = new SelectList(db.Especie.OrderBy(c => c.Nombre), "ID", "Nombre", item.EspecieID);
try
{
ViewBag.ComprobanteEgreso = item.Egreso.Egreso.NumeroComprobante;
}
catch (Exception)
{
ViewBag.ComprobanteEgreso = "";
}
ViewBag.Resolucion = db.InventarioBaja.Where(i => i.MovimientoID == movimientoID && i.ItemID == id).Single().Resolucion;
}
else
{
ViewBag.ID = 0;
ViewBag.EspecieID = new SelectList(db.Especie.OrderBy(c => c.Nombre), "ID", "Nombre");
}
ViewBag.Inventario = db.InventarioItem.Where(i => i.ProyectoID == Proyecto.ID && i.Cantidad > 0).ToList();
return(View(item));
}
public void InsertarItemMethod_OK()
{
#region Arrange
InventarioItem expected = new InventarioItem()
{
Id = Guid.NewGuid(),
Nombre = "item 1",
Unidades = 100,
FechaCaducidad = DateTime.UtcNow.AddDays(5)
};
InventarioItemViewModel itemToInsert = new InventarioItemViewModel()
{
Id = Guid.NewGuid(),
Nombre = "item 1",
Unidades = 100,
FechaCaducidad = DateTime.UtcNow.AddDays(5).ToString()
};
IInventarioItemManager manager = CreateInventarioItemManager();
_inventarioItemServiceMocked.Setup(s => s.InsertarItem(It.IsAny <InventarioItem>())).Returns(Task.FromResult(expected));
#endregion
#region Act
var actual = manager.InsertarItem(itemToInsert).Result;
#endregion
#region Assert
Assert.IsNotNull(actual);
Assert.IsTrue(actual is InventarioItemViewModel);
Assert.AreEqual(itemToInsert.Id, actual.Id);
_inventarioItemServiceMocked.Verify(s => s.InsertarItem(It.IsAny <InventarioItem>()), Times.Once);
#endregion
}
public async Task RemoveAsync(int id)
{
try
{
InventarioItem obj = await _context.InventarioItem
.Include(x => x.Inventario)
.Include(x => x.Inventario.CentroDeCusto)
.FirstOrDefaultAsync(x => x.Id == id);
_context.InventarioItem.Remove(obj);
await _context.SaveChangesAsync();
await Auditoria(obj.Inventario.CentroDeCusto.EmpresaId,
Modulo.Estoque,
SubModulo.Inventario,
Operacao.Exclusao,
"TODO");
}
catch (DbUpdateException e)
{
throw new IntegrityException(e.Message);
}
}
public InvItemObj(PWClient client, uint basePointer)
{
this.Client = client;
this.BasePointer = basePointer;
this.Data = this.Client.MemMgr.ReadStruct <InventarioItem>(this.BasePointer);
}
public ActionResult Alta(InventarioItem item)
{
Proyecto Proyecto = (Proyecto)Session["Proyecto"];
Persona Persona = (Persona)Session["Persona"];
string resolucion = Request.Form["Resolucion"].ToString();
int movimientoID = Convert.ToInt32(Request.Form["MovimientoID"].ToString());
item.ProyectoID = Proyecto.ID;
item.Estado = "P";
InventarioMovimiento movimiento = new InventarioMovimiento();
InventarioAlta alta = new InventarioAlta();
// Primer ingreso al inventario
if (movimientoID == 0)
{
movimiento.PersonaID = Persona.ID;
movimiento.ProyectoID = Proyecto.ID;
movimiento.FechaCreacion = DateTime.Now;
movimiento.FechaModificacion = DateTime.Now;
movimiento.Movimiento = "A";
db.InventarioMovimiento.Add(movimiento);
db.SaveChanges();
movimientoID = movimiento.ID;
}
else
{
movimiento = db.InventarioMovimiento.Find(movimientoID);
movimiento.FechaModificacion = DateTime.Now;
db.Entry(movimiento).State = EntityState.Modified;
db.SaveChanges();
}
// Ingreso nuevo
if (item.ID == 0)
{
db.InventarioItem.Add(item);
db.SaveChanges();
alta.MovimientoID = movimientoID;
alta.ItemID = item.ID;
alta.Cantidad = item.Cantidad;
alta.Fecha = DateTime.Now;
alta.Resolucion = resolucion;
db.InventarioAlta.Add(alta);
db.SaveChanges();
}
else
{
alta = db.InventarioAlta.Where(i => i.MovimientoID == movimientoID && i.ItemID == item.ID).Single();
alta.Resolucion = resolucion;
db.Entry(alta).State = EntityState.Modified;
db.SaveChanges();
db.Entry(item).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Alta", "Inventario", new { movimientoID = movimientoID, id = 0 }));
}
