public ActionResult Crear(tbRol nuevo)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbRol.Any(t => t.rol == nuevo.rol)))
{
db.tbRol.Add(nuevo);
db.SaveChanges();
List <int> permisos = db.tbPermiso.Select(t => t.codPermiso).ToList();
List <tbRolPermiso> rolPermisos = new List <tbRolPermiso>();
foreach (int item in permisos)
{
rolPermisos.Add(new tbRolPermiso
{
codRol = nuevo.codRol,
codPermiso = item,
estado = false
});
}
db.tbRolPermiso.AddRange(rolPermisos);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe este rol!");
return(View());
}
}
public ActionResult CambiarEstado(int id, FormCollection collection)
{
dbHeredadesEntities db = new dbHeredadesEntities();
tbTransaccion transaccion = db.tbTransaccion.Find(id);
transaccion.estado = !(transaccion.estado);
if (transaccion.codTipoTransaccion == 0)
{
db.SaveChanges();
return(RedirectToAction("Pedidos"));
}
else
{
foreach (tbProductoTransaccion item in transaccion.tbProductoTransaccion)
{
tbProductoPresentacion prod = db.tbProductoPresentacion.Find(item.codProducto, item.codPresentacion);
if (transaccion.estado)
{
prod.existencia -= item.cantidad;
}
else
{
prod.existencia += item.cantidad;
}
}
db.SaveChanges();
return(RedirectToAction("Salidas"));
}
}
public ActionResult Create([Bind(Include = "codProducto,codCategoria,producto,estado")] tbProducto tbProducto)
{
if (ModelState.IsValid)
{
db.tbProducto.Add(tbProducto);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.codCategoria = new SelectList(db.tbCategoria, "codCategoria", "categoria", tbProducto.codCategoria);
return(View(tbProducto));
}
public int CrearPedido(int codProveedor, List <tbProductoTransaccion> lista, string descripcion)
{
try
{
dbHeredadesEntities db = new dbHeredadesEntities();
// creo el objeto transacción
tbTransaccion nuevaEntrada = new tbTransaccion
{
codProveedor = codProveedor,
codTipoTransaccion = 0,
codUsuario = Sesion.ObtenerCodigo(),
descripcion = descripcion,
fecha = DateTime.Now,
estado = true
};
// se agregan todos los productos al pedido pero sin precio
foreach (tbProductoTransaccion item in lista)
{
nuevaEntrada.tbProductoTransaccion.Add(item);
}
//agrego la transaccion y guardo cambios
db.tbTransaccion.Add(nuevaEntrada);
db.SaveChanges();
return(1);
}
catch (Exception)
{
return(2);
}
}
public int CrearSalida(List <tbProductoTransaccion> lista, string descripcion)
{
try
{
dbHeredadesEntities db = new dbHeredadesEntities();
// creo la nueva transacción
tbTransaccion nuevaSalida = new tbTransaccion
{
codUsuario = Sesion.ObtenerCodigo(),
codTipoTransaccion = 2,
descripcion = descripcion,
fecha = DateTime.Now,
estado = true
};
foreach (tbProductoTransaccion item in lista)
{
nuevaSalida.tbProductoTransaccion.Add(item);
//quito la existencia del producto
tbProductoPresentacion prod = db.tbProductoPresentacion.Find(item.codProducto, item.codPresentacion);
prod.existencia -= item.cantidad;
}
db.tbTransaccion.Add(nuevaSalida);
db.SaveChanges();
return(1);
}
catch (Exception ex)
{
return(2);
}
}
public ActionResult CrearTransaccion(tbTransaccionCaja transaccion)
{
dbHeredadesEntities db = new dbHeredadesEntities();
int usuario = Sesion.ObtenerCodigo();
transaccion.codUsuario = Sesion.ObtenerCodigo();
transaccion.fecha = DateTime.Now;
db.tbTransaccionCaja.Add(transaccion);
if (transaccion.tipoTransaccion == 0)
{
CajaController.Sumar(transaccion.cantidad);
}
else
{
CajaController.Restar(transaccion.cantidad);
}
db.SaveChanges();
switch (transaccion.tipoTransaccion)
{
case 0:
return(RedirectToAction("Ingresos"));
case 1:
return(RedirectToAction("Gastos"));
case 2:
return(RedirectToAction("Retiros"));
default:
return(RedirectToAction("Index"));
}
}
public int Guardar(ProductoPresentaciones modelo)
{
if (modelo.presentaciones == null)
{
return(3);
}
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbProducto.Any(t => t.producto == modelo.producto.producto)))
{
modelo.producto.estado = true;
short correlativo = 1;
foreach (tbProductoPresentacion presentacion in modelo.presentaciones)
{
presentacion.correlativo = correlativo;
modelo.producto.tbProductoPresentacion.Add(presentacion);
correlativo++;
}
db.tbProducto.Add(modelo.producto);
db.SaveChanges();
return(1);
}
else
{
return(2);
}
}
public static void Restar(decimal cantidad)
{
dbHeredadesEntities db = new dbHeredadesEntities();
tbCaja caja = db.tbCaja.Find(1);
caja.cantidad -= cantidad;
db.SaveChanges();
}
public ActionResult CambiarEstadoPermiso(int codRol, int codPermiso)
{
dbHeredadesEntities db = new dbHeredadesEntities();
tbRolPermiso permiso = db.tbRolPermiso.Find(codRol, codPermiso);
permiso.estado = !(permiso.estado);
db.SaveChanges();
return(PartialView("_ListaPermisos", (from t in db.tbRolPermiso where t.codRol == codRol select t).ToList()));
}
public ActionResult CambiarEstado(int id, FormCollection collection)
{
dbHeredadesEntities db = new dbHeredadesEntities();
tbProveedor proveedor = db.tbProveedor.Find(id);
proveedor.estado = !(proveedor.estado);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult CambiarEstado(int id, FormCollection collection)
{
dbHeredadesEntities db = new dbHeredadesEntities();
tbUsuario usuario = db.tbUsuario.Find(id);
usuario.estado = !(usuario.estado);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult CambiarEstado(int id, FormCollection collection)
{
dbHeredadesEntities db = new dbHeredadesEntities();
tbCategoria categoria = db.tbCategoria.Find(id);
categoria.estado = !(categoria.estado);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public int CrearDeudor(tbDeudor deudor)
{
dbHeredadesEntities db = new dbHeredadesEntities();
deudor.deuda = 0;
db.tbDeudor.Add(deudor);
db.SaveChanges();
return(deudor.codDeudor);
}
//Se encarga de toda la logica previa a realizar una conversión
public bool Convertir(int codProducto, int codPresentacion)
{
dbHeredadesEntities db = new dbHeredadesEntities();
tbProductoPresentacion prod = db.tbProductoPresentacion.Find(codProducto, codPresentacion);
tbProductoPresentacion correlativoMayor = db.tbProductoPresentacion.Where(t => t.codProducto == prod.codProducto && t.correlativo == (prod.correlativo + 1)).SingleOrDefault();
if (correlativoMayor != null)
{
//si existe un correlativo mayor se verifica si tiene existencia
if (correlativoMayor.existencia > 0)
{
//si tiene al menos una unidad de existencia, se realiza la conversión
tbProductoPresentacion mayor = db.tbProductoPresentacion.Where(t => t.codProducto == prod.codProducto && t.correlativo == (prod.correlativo + 1)).SingleOrDefault();
mayor.existencia -= 1;
prod.existencia += mayor.unidades;
db.SaveChanges();
return(true);
}
else
{
//si no tiene nada en existencia se intenta con un correlativo mayor
tbProductoPresentacion convertir = db.tbProductoPresentacion.Where(t => t.codProducto == prod.codProducto && t.correlativo == (prod.correlativo + 1)).SingleOrDefault();
if (Convertir(convertir.codProducto, convertir.codPresentacion))
{
//se realiza conversion
tbProductoPresentacion mayor = db.tbProductoPresentacion.Where(t => t.codProducto == prod.codProducto && t.correlativo == (prod.correlativo + 1)).SingleOrDefault();
mayor.existencia -= 1;
prod.existencia += mayor.unidades;
db.SaveChanges();
return(true);
}
else
{
return(false);
}
}
}
else
{
return(false);
}
}
public ActionResult Editar(tbCategoria editada)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbCategoria.Any(t => t.categoria == editada.categoria && t.codCategoria != editada.codCategoria)))
{
db.Entry(editada).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe esta categoría!");
return(View(editada));
}
}
public ActionResult Editar(tbPresentacion editada)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbPresentacion.Any(t => t.presentacion == editada.presentacion && t.codPresentacion != editada.codPresentacion)))
{
db.Entry(editada).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe esta presentación!");
return(View(editada));
}
}
public ActionResult Editar(tbDeudor deudor)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbDeudor.Any(t => t.nombre == deudor.nombre && t.codDeudor != deudor.codDeudor)))
{
db.Entry(deudor).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe este deudor!");
return(View(deudor));
}
}
public ActionResult Editar(tbProveedor editado)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbProveedor.Any(t => t.proveedor == editado.proveedor && t.codProveedor != editado.codProveedor)))
{
db.Entry(editado).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe este proveedor!");
return(View(editado));
}
}
public ActionResult Editar(tbRol editado)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbRol.Any(t => t.rol == editado.rol && t.codRol != editado.codRol)))
{
db.Entry(editado).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe un rol con ese nombre!");
return(View());
}
}
public ActionResult Crear(tbDeudor nuevo)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbDeudor.Any(t => t.nombre == nuevo.nombre)))
{
nuevo.deuda = 0;
db.tbDeudor.Add(nuevo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe este proveedor!");
return(View(nuevo));
}
}
public ActionResult Crear(tbCategoria nueva)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbCategoria.Any(t => t.categoria == nueva.categoria)))
{
nueva.estado = true;
db.tbCategoria.Add(nueva);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe esta categoría!");
return(View(nueva));
}
}
public ActionResult Crear(tbProveedor nuevo)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbProveedor.Any(t => t.proveedor == nuevo.proveedor)))
{
nuevo.estado = true;
nuevo.deuda = 0;
db.tbProveedor.Add(nuevo);
db.SaveChanges();
return(RedirectToAction("Productos", new { id = nuevo.codProveedor }));
}
else
{
ModelState.AddModelError(string.Empty, "¡Ya existe este proveedor!");
return(View(nuevo));
}
}
public ActionResult Crear(tbUsuario nuevo)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbUsuario.Any(t => t.usuario == nuevo.usuario)))
{
nuevo.estado = true;
db.tbUsuario.Add(nuevo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
List <tbRol> roles = db.tbRol.Where(t => t.codRol != 1).OrderBy(t => t.rol).ToList();
ViewBag.codRol = new SelectList(roles, "codRol", "rol");
ModelState.AddModelError(string.Empty, "¡Ya existe este nombre de usuario!");
return(View());
}
}
public ActionResult Editar(tbUsuario editado)
{
dbHeredadesEntities db = new dbHeredadesEntities();
if (!(db.tbUsuario.Any(t => t.codUsuario != editado.codUsuario && t.usuario == editado.usuario)))
{
editado.password = db.tbUsuario.Find(editado.codUsuario).password;
db.Entry(editado).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
List <tbRol> roles = db.tbRol.Where(t => t.codRol != 1).OrderBy(t => t.rol).ToList();
ViewBag.codRol = new SelectList(roles, "codRol", "rol");
ModelState.AddModelError(string.Empty, "¡Ya existe ese usuario!");
return(View());
}
}
public int GuardarProductos(List <tbProductoProveedor> modelo)
{
try
{
dbHeredadesEntities db = new dbHeredadesEntities();
int codProveedor = modelo[0].codProveedor;
List <tbProductoProveedor> guardadas = db.tbProductoProveedor.Where(t => t.codProveedor == codProveedor).ToList();
List <int> deshabilitar = new List <int>();
foreach (tbProductoProveedor item in modelo)
{
if (guardadas.Any(t => t.codProveedor == item.codProveedor && t.codProducto == item.codProducto && t.codPresentacion == item.codPresentacion))
{
//esta en bd
int index = guardadas.FindIndex(t => t.codProveedor == item.codProveedor && t.codProducto == item.codProducto && t.codPresentacion == item.codPresentacion);
if (index > -1)
{
guardadas[index].precioCompra = item.precioCompra;
guardadas[index].estado = true;
}
deshabilitar.Add(index);
}
else
{
//no esta en bd
db.tbProductoProveedor.Add(item);
}
}
for (int i = 0; i < guardadas.Count; i++)
{
if (!deshabilitar.Contains(i))
{
guardadas[i].estado = false;
}
}
db.SaveChanges();
return(1);
}
catch (Exception)
{
return(0);
}
}
public ActionResult CambiarEstado(int id, FormCollection collection)
{
dbHeredadesEntities db = new dbHeredadesEntities();
// obtengo el pago y le cambio el estado
tbPagoProveedor pago = db.tbPagoProveedor.Find(id);
pago.estado = !(pago.estado);
// en este punto, el estado es el final, si es verdadero (se habilita) se resta de la deuda, si es falso (se deshabilito) sumar a la deuda
tbProveedor proveedor = db.tbProveedor.Find(pago.codProveedor);
if (pago.estado)
{
proveedor.deuda -= pago.pago;
}
else
{
proveedor.deuda += pago.pago;
}
db.SaveChanges();
return(RedirectToAction("VerPagos", new { id = pago.codProveedor }));
}
public ActionResult Pagar(int codDeudor, decimal pago)
{
dbHeredadesEntities db = new dbHeredadesEntities();
tbPagoDeudor debitar = new tbPagoDeudor
{
codDeudor = codDeudor,
codUsuario = Sesion.ObtenerCodigo(),
pago = pago,
fecha = DateTime.Now
};
db.tbPagoDeudor.Add(debitar);
tbDeudor deudor = db.tbDeudor.Find(codDeudor);
deudor.deuda -= pago;
tbCaja caja = db.tbCaja.Find(1);
caja.cantidad += pago;
db.SaveChanges();
return(RedirectToAction("Pagos", new { id = codDeudor }));
}
public int CrearEntrada(int codProveedor, List <tbProductoTransaccion> lista, string descripcion)
{
try
{
dbHeredadesEntities db = new dbHeredadesEntities();
// creo el objeto transacción
tbTransaccion nuevaEntrada = new tbTransaccion
{
codProveedor = codProveedor,
codTipoTransaccion = 1,
codUsuario = Sesion.ObtenerCodigo(),
descripcion = descripcion,
fecha = DateTime.Now,
estado = true
};
decimal deuda = 0;
foreach (tbProductoTransaccion item in lista)
{
// se asigna el precio de compra al item y se agrega a la tabla JOIN de productoTransacción
item.precioCompra = db.tbProductoProveedor.Find(codProveedor, item.codProducto, item.codPresentacion).precioCompra;
nuevaEntrada.tbProductoTransaccion.Add(item);
// se agrega a la existencia del producto
tbProductoPresentacion prod = db.tbProductoPresentacion.Find(item.codProducto, item.codPresentacion);
prod.existencia += item.cantidad;
// sumo a la deuda precioCompra * cantidadEntrada.
deuda += item.cantidad * item.precioCompra.Value;
}
// calculo deuda total de entrada y la sumo a deuda total al proveedor.
tbProveedor proveedor = db.tbProveedor.Find(codProveedor);
proveedor.deuda += deuda;
//agrego la transaccion y guardo cambios
db.tbTransaccion.Add(nuevaEntrada);
db.SaveChanges();
return(1);
}
catch (Exception)
{
return(2);
}
}
public ActionResult RecivirPedido(int id)
{
dbHeredadesEntities db = new dbHeredadesEntities();
// obtengo el pedido y lo convierto en una entrada
tbTransaccion transaccion = db.tbTransaccion.Find(id);
transaccion.codTipoTransaccion = 1;
// cambio el usuario por el que recive el pedido
transaccion.codUsuario = Sesion.ObtenerCodigo();
transaccion.fecha = DateTime.Now;
foreach (tbProductoTransaccion item in transaccion.tbProductoTransaccion)
{
// a cada producto comprado le ingreso el precio de compra
item.precioCompra = db.tbProductoProveedor.Find(transaccion.codProveedor, item.codProducto, item.codPresentacion).precioCompra;
// agrego la entrada a la existencia
tbProductoPresentacion producto = db.tbProductoPresentacion.Find(item.codProducto, item.codPresentacion);
producto.existencia += item.cantidad;
// agrego la deuda al proveedor
tbProveedor proveedor = db.tbProveedor.Find(transaccion.codProveedor);
proveedor.deuda += item.precioCompra.Value * item.cantidad;
}
db.SaveChanges();
return(RedirectToAction("Pedidos"));
}
public ActionResult Pagar(FormCollection collection)
{
dbHeredadesEntities db = new dbHeredadesEntities();
// creo objeto representante del pago
tbPagoProveedor pago = new tbPagoProveedor
{
codProveedor = int.Parse(collection["codProveedor"]),
codUsuario = Sesion.ObtenerCodigo(),
fecha = DateTime.Now,
pago = decimal.Parse(collection["pago"]),
descripcion = collection["descripcion"],
estado = true
};
// llamo al proveedor para restarle la deuda
tbProveedor proveedor = db.tbProveedor.Find(pago.codProveedor);
proveedor.deuda -= pago.pago;
//agrego el pago a la tabla y guardo cambios
db.tbPagoProveedor.Add(pago);
if (collection["rdFuente"] == "caja")
{
//el pago se debe de efectuar desde caja, de lo contrario no se resta nada de caja
tbTransaccionCaja transaccionCaja = new tbTransaccionCaja
{
tipoTransaccion = 1,
codUsuario = Sesion.ObtenerCodigo(),
cantidad = pago.pago,
fecha = DateTime.Now,
descripcion = "Pago a " + proveedor.proveedor
};
CajaController.Restar(pago.pago);
db.tbTransaccionCaja.Add(transaccionCaja);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
