public async Task <int> CrearAsync(ProveedorDetalle proveedor, int usuarioId)
{
var nombre = proveedor.Nombre.Trim().ToLowerInvariant();
var nombreContacto = proveedor.NombreDeContacto?.Trim()?.ToLowerInvariant();
var direccion = proveedor.Direccion?.Trim()?.ToLowerInvariant();
if (await ExisteProveedor(nombre))
{
throw new InvalidOperationException($"El proveedor {nombre} ya existe.");
}
var nuevoProveedor = new Proveedor
{
Nombre = nombre,
NombreDeContacto = nombreContacto,
Direccion = direccion,
UsuarioCreacionId = usuarioId,
UsuarioModificaId = usuarioId
};
db.Proveedores.Add(nuevoProveedor);
var filasAfectadas = await db.SaveChangesAsync();
if (filasAfectadas > 0)
{
return(nuevoProveedor.Id);
}
else
{
return(-1);
}
}
public async Task <int> CrearAsync(MarcaResumen marca)
{
var nombre = marca.Nombre.ToLowerInvariant();
if (await ExisteMarca(nombre))
{
throw new InvalidOperationException($"La marca '{nombre}' ya existe.");
}
var nuevaMarca = new Marca
{
Nombre = nombre
};
db.Marcas.Add(nuevaMarca);
var filasAfectadas = await db.SaveChangesAsync();
if (filasAfectadas > 0)
{
return(nuevaMarca.Id);
}
else
{
return(-1);
}
}
public async Task <int> CrearAsync(BodegaResumen bodega, int usuarioId)
{
var nombre = bodega.Nombre.ToLowerInvariant();
var direccion = bodega.Direccion.ToLowerInvariant();
if (await ExisteBodega(nombre))
{
throw new InvalidOperationException($"La bodega '{nombre}' ya existe.");
}
var nuevaBodega = new Bodega
{
Nombre = nombre,
Direccion = direccion,
UsuarioCreacionId = usuarioId,
UsuarioModificaId = usuarioId
};
db.Bodegas.Add(nuevaBodega);
var filasAfectadas = await db.SaveChangesAsync();
if (filasAfectadas > 0)
{
return(nuevaBodega.Id);
}
else
{
return(-1);
}
}
public async Task <int> CrearAsync(UnidadDeMedidaResumen unidadMedida)
{
var nombre = unidadMedida.Nombre.ToLowerInvariant();
if (await ExisteUnidadDeMedida(nombre))
{
throw new InvalidOperationException($"La unidad de medida '{nombre}' ya existe.");
}
var nuevaUnidad = new UnidadDeMedida
{
Nombre = nombre
};
db.UnidadesDeMedida.Add(nuevaUnidad);
var filasAfectadas = await db.SaveChangesAsync();
if (filasAfectadas > 0)
{
return(nuevaUnidad.Id);
}
else
{
return(-1);
}
}
public async Task <int> CrearAsync(ListaDetalle lista)
{
var nombre = lista.Nombre.Trim();
if (await ExisteNombre(nombre))
{
throw new InvalidOperationException($"Ya existe una lista con el nombre '{nombre}'.");
}
var nuevaLista = new Lista
{
Nombre = nombre
};
db.Listas.Add(nuevaLista);
var filasAfectadas = await db.SaveChangesAsync();
if (filasAfectadas > 0)
{
return(nuevaLista.Id);
}
else
{
return(-1);
}
}
public async Task <int> CrearAsync(ProductoDetalle producto)
{
var nombre = producto.Nombre.Trim();
var descripcion = producto.Descripcion.Trim();
if (await ExisteNombre(nombre))
{
throw new InvalidOperationException($"Ya existe un producto con el nombre '{nombre}'.");
}
var nuevoProducto = new Producto {
Nombre = nombre,
Descripcion = descripcion
};
if (producto.Marcas != null && producto.Marcas.Length > 0)
{
nuevoProducto.Marcas = producto.Marcas.Select(marcaId => new ProductoMarca {
Producto = nuevoProducto,
MarcaId = marcaId
}).ToList();
}
if (producto.Unidades != null && producto.Unidades.Length > 0)
{
nuevoProducto.UnidadesDeMedida = producto.Unidades.Select(unidadId => new ProductoUnidadDeMedida {
Producto = nuevoProducto,
UnidadDeMedidaId = unidadId
}).ToList();
}
if (producto.Caracteristicas != null && producto.Caracteristicas.Length > 0)
{
nuevoProducto.Caracteristicas = producto.Caracteristicas.Select(c => new ProductoCaracteristica {
Producto = nuevoProducto,
TipoCaracteristica = (ProductoTipoCaracteristica)c.Tipo,
Nombre = c.Nombre,
ListaId = c.ListaId,
Minimo = c.Minimo,
Maximo = c.Maximo,
Requerido = c.Requerido,
ExpresionDeValidacion = null
}).ToList();
}
db.Productos.Add(nuevoProducto);
var filasAfectadas = await db.SaveChangesAsync();
if (filasAfectadas > 0)
{
return(nuevoProducto.Id);
}
else
{
return(-1);
}
}
public async Task <int> CrearAsync(UsuarioDetalle usuario)
{
var login = usuario.Login.Trim().ToLowerInvariant();
var correo = usuario.Correo.Trim().ToLowerInvariant();
if (string.IsNullOrWhiteSpace(usuario.Clave))
{
throw new InvalidOperationException("La clave no puede estar en blanco");
}
if (await ExisteLoginInterno(login))
{
throw new InvalidOperationException($"El login '{login}' ya está asignado a otro usuario.");
}
if (await ExisteCorreoInterno(correo))
{
throw new InvalidOperationException($"El correo '{correo}' ya está asignado a otro usuario.");
}
var nuevoUsuario = new Usuario {
Login = login,
Nombres = usuario.Nombres.Trim(),
Apellidos = usuario.Apellidos.Trim(),
NombreCompleto = usuario.NombreCompleto.Trim(),
Correo = correo,
SitioWeb = usuario.SitioWeb?.Trim().ToLowerInvariant(),
Activo = true,
CorreoVerificado = false,
Clave = usuario.Clave.Encriptar()
};
if (usuario.Roles != null && usuario.Roles.Count > 0)
{
var rolesIds = usuario.Roles.Keys;
var roles = db.Roles.Where(x => rolesIds.Contains(x.Id)).Distinct().ToList();
if (rolesIds.Count != roles.Count)
{
throw new InvalidOperationException("Al menos uno de los roles especificados no es válido.");
}
nuevoUsuario.Roles = roles.Select(x => new UsuarioRol
{
Usuario = nuevoUsuario,
Rol = x
}).ToList();
}
if (usuario.Atributos != null && usuario.Atributos.Count > 0)
{
nuevoUsuario.Atributos = new List <UsuarioAtributo>();
foreach (var atributo in usuario.Atributos)
{
if (string.IsNullOrWhiteSpace(atributo.Key))
{
continue;
}
foreach (var valor in atributo.Value)
{
if (string.IsNullOrEmpty(valor))
{
continue;
}
nuevoUsuario.Atributos.Add(new UsuarioAtributo
{
Nombre = atributo.Key.Trim().ToLowerInvariant(),
Valor = valor.Trim(),
Usuario = nuevoUsuario
});
}
}
}
db.Usuarios.Add(nuevoUsuario);
var filasAfectadas = await db.SaveChangesAsync();
if (filasAfectadas > 0)
{
return(nuevoUsuario.Id);
}
else
{
return(-1);
}
}
public async Task <int> CrearAsync(int usuarioId, IngresoDetalle ingreso)
{
if (ingreso == null)
{
throw new ArgumentNullException(nameof(ingreso));
}
if (ingreso.Productos == null || ingreso.Productos.Length == 0)
{
throw new InvalidOperationException("No puede crear un ingreso sin productos.");
}
var tieneProductosRepetidos = ingreso.Productos.GroupBy(x => new { x.ProductoId, x.MarcaId, x.UnidadId }).Where(x => x.Count() > 1).Any();
if (tieneProductosRepetidos)
{
throw new InvalidOperationException("Un ingreso no puede tener un producto repetido con la misma marca y unidad de medida (debe crear dos ingresos distintos)");
}
var hayProductosSinCantidad = ingreso.Productos.Any(x => x.Cantidad <= 0);
if (hayProductosSinCantidad)
{
throw new InvalidOperationException("Un ingreso no puede contener productos con valores menores o iguales a cero");
}
var hayProductosConPrecioNegativo = ingreso.Productos.Any(x => x.Precio < 0);
if (hayProductosConPrecioNegativo)
{
throw new InvalidOperationException("Un ingreso no puede contener productos con precio negativo");
}
var existeProveedor = await db.Proveedores.AnyAsync(x => x.Id == ingreso.ProveedorId);
if (!existeProveedor)
{
throw new InvalidOperationException($"No existe el proveedor con id {ingreso.ProveedorId}");
}
var existeBodega = await db.Bodegas.AnyAsync(x => x.Id == ingreso.BodegaId);
if (!existeBodega)
{
throw new InvalidOperationException($"No existe una bodega con id {ingreso.BodegaId}");
}
var productosIds = ingreso.Productos.Select(x => x.ProductoId).Distinct().ToArray();
var cantidadDeProductos = await db.Productos.CountAsync(x => productosIds.Contains(x.Id));
var existenTodosLosProductos = cantidadDeProductos == productosIds.Length;
if (!existenTodosLosProductos)
{
throw new InvalidOperationException("Al menos uno de los productos indicados no existe");
}
var marcasParaLosProductos = await db.ProductoMarcas.Where(x => productosIds.Contains(x.ProductoId)).ToArrayAsync();
var unidadesParaLosProductos = await db.ProductoUnidadesDeMedida.Where(x => productosIds.Contains(x.ProductoId)).ToArrayAsync();
//var caracteristicasParaLosProductos = await db.ProductoCaracteristicas.Where(x => productosIds.Contains(x.ProductoId)).ToArrayAsync();
foreach (var item in ingreso.Productos)
{
if (!marcasParaLosProductos.Any(x => x.MarcaId == item.MarcaId && x.ProductoId == item.ProductoId))
{
throw new InvalidOperationException($"No existe una marca con id {item.MarcaId} o no está asignada al producto con id {item.ProductoId}");
}
if (!unidadesParaLosProductos.Any(x => x.UnidadDeMedidaId == item.UnidadId && x.ProductoId == item.ProductoId))
{
throw new InvalidOperationException($"No existe una unidad de medida con id {item.UnidadId} o no está asignada al producto con id {item.ProductoId}");
}
// TODO: Validar caracteristicas (requeridas, existentes, etc.)
}
// NOTA: muchas de las validaciones anteriores podrían implementarse como DataAnnotations
// para que puedan ser utilizadas por otros controllers y delegar esas tareas de
// validación al motor de MVC por medio de atributos en los modelos.
if (ingreso.Fecha == default(DateTime))
{
ingreso.Fecha = DateTime.UtcNow;
}
var nuevoIngreso = new Ingreso {
Fecha = ingreso.Fecha.ToUniversalTime(),
UsuarioId = usuarioId,
BodegaId = ingreso.BodegaId,
ProveedorId = ingreso.ProveedorId,
Productos = ingreso.Productos.Select(producto => new IngresoProducto {
ProductoId = producto.ProductoId,
MarcaId = producto.MarcaId,
UnidadDeMedidaId = producto.UnidadId,
Cantidad = producto.Cantidad,
Precio = producto.Precio,
NumeroDeSerie = producto.Serie,
Caracteristicas = producto.Caracteristicas?.Select(caracteristica => new IngresoProductoCaracteristica {
CaracteristicaId = caracteristica.Id,
ListaValorId = caracteristica.ListaValorId,
Valor = caracteristica.Valor
}).ToArray()
}).ToArray()
};
db.Ingresos.Add(nuevoIngreso);
var existencias = await db.Existencias.Include(x => x.Cantidades).Where(x => productosIds.Contains(x.ProductoId)).ToListAsync();
foreach (var item in ingreso.Productos)
{
var productoId = item.ProductoId;
var nuevaCantidad = item.Cantidad;
var marcaId = item.MarcaId;
var unidadId = item.UnidadId;
var existencia = existencias.FirstOrDefault(x => x.ProductoId == productoId);
if (existencia == null)
{
existencia = new Existencia
{
ProductoId = productoId,
Cantidades = new List <ExistenciaCantidad> {
new ExistenciaCantidad {
Cantidad = nuevaCantidad,
FechaModificacion = DateTime.UtcNow,
MarcaId = marcaId,
UnidadDeMedidaId = unidadId
}
}
};
db.Existencias.Add(existencia);
existencias.Add(existencia);
}
else
{
var cantidad = existencia.Cantidades.FirstOrDefault(x => x.UnidadDeMedidaId == unidadId && x.MarcaId == marcaId);
if (cantidad == null)
{
cantidad = new ExistenciaCantidad {
Cantidad = nuevaCantidad,
FechaModificacion = DateTime.UtcNow,
MarcaId = marcaId,
UnidadDeMedidaId = unidadId
};
existencia.Cantidades.Add(cantidad);
}
else
{
cantidad.Cantidad += nuevaCantidad;
}
}
}
await db.SaveChangesAsync();
return(nuevoIngreso.Id);
}
public async Task <int> CrearAsync(int usuarioId, EgresoDetalle egreso)
{
if (egreso == null)
{
throw new ArgumentNullException(nameof(egreso));
}
if (egreso.Productos == null || egreso.Productos.Count() == 0)
{
throw new InvalidOperationException("No puede crear un egreso sin productos.");
}
var tieneProductosRepetidos = egreso.Productos.GroupBy(x => new { x.ProductoId, x.MarcaId, x.UnidadId }).Where(x => x.Count() > 1).Any();
if (tieneProductosRepetidos)
{
throw new InvalidOperationException("Un egreso no puede tener un producto repetido con la misma marca y unidad de medida (debe crear dos egresos distintos)");
}
var hayProductosSinCantidad = egreso.Productos.Any(x => x.Cantidad <= 0);
if (hayProductosSinCantidad)
{
throw new InvalidOperationException("Un egreso no puede contener productos con valores menores o iguales a cero");
}
var existeBodega = await db.Bodegas.AnyAsync(x => x.Id == egreso.BodegaId);
if (!existeBodega)
{
throw new InvalidOperationException($"No existe una bodega con id {egreso.BodegaId}");
}
var productosIds = egreso.Productos.Select(x => x.ProductoId).Distinct().ToArray();
var cantidadDeProductos = await db.Productos.CountAsync(x => productosIds.Contains(x.Id));
var existenTodosLosProductos = cantidadDeProductos == productosIds.Length;
if (!existenTodosLosProductos)
{
throw new InvalidOperationException("Al menos uno de los productos indicados no existe");
}
var marcasParaLosProductos = await db.ProductoMarcas.Where(x => productosIds.Contains(x.ProductoId)).ToArrayAsync();
var unidadesParaLosProductos = await db.ProductoUnidadesDeMedida.Where(x => productosIds.Contains(x.ProductoId)).ToArrayAsync();
foreach (var item in egreso.Productos)
{
if (!marcasParaLosProductos.Any(x => x.MarcaId == item.MarcaId && x.ProductoId == item.ProductoId))
{
throw new InvalidOperationException($"No existe una marca con id {item.MarcaId} o no está asignada al producto con id {item.ProductoId}");
}
if (!unidadesParaLosProductos.Any(x => x.UnidadDeMedidaId == item.UnidadId && x.ProductoId == item.ProductoId))
{
throw new InvalidOperationException($"No existe una unidad de medida con id {item.UnidadId} o no está asignada al producto con id {item.ProductoId}");
}
}
if (egreso.Fecha == default(DateTime))
{
egreso.Fecha = DateTime.UtcNow;
}
var nuevoEgreso = new Egreso
{
Fecha = egreso.Fecha.ToUniversalTime(),
UsuarioId = usuarioId,
BodegaId = egreso.BodegaId
};
if (egreso.Productos != null && egreso.Productos.Count() > 0)
{
nuevoEgreso.Productos = egreso.Productos.Select(producto => new EgresoProducto {
Egreso = nuevoEgreso,
ProductoId = producto.ProductoId,
UnidadDeMedidaId = producto.UnidadId,
Cantidad = producto.Cantidad,
MarcaId = producto.MarcaId
}).ToList();
}
db.Egresos.Add(nuevoEgreso);
var existencias = await db.Existencias.Include(x => x.Cantidades).Where(x => productosIds.Contains(x.ProductoId)).ToListAsync();
foreach (var item in egreso.Productos)
{
var productoId = item.ProductoId;
var nuevaCantidad = item.Cantidad;
var marcaId = item.MarcaId;
var unidadId = item.UnidadId;
var existencia = existencias.FirstOrDefault(x => x.ProductoId == productoId);
if (existencia == null)
{
throw new InvalidOperationException($"No hay existencias suficientes para el producto {item.ProductoId}");
}
else
{
var cantidad = existencia.Cantidades.FirstOrDefault(x => x.UnidadDeMedidaId == unidadId && x.MarcaId == marcaId);
if (cantidad == null)
{
throw new InvalidOperationException($"No hay existencias suficientes para el producto {item.ProductoId}");
}
else
{
if (cantidad.Cantidad < nuevaCantidad)
{
throw new InvalidOperationException($"La cantidad que se desea sacar del producto {item.ProductoId} es mayor a la cantidad disponible");
}
else
{
cantidad.Cantidad -= nuevaCantidad;
}
}
}
}
await db.SaveChangesAsync();
return(nuevoEgreso.Id);
}