/*
*Propósito: Permite consultar un usuario por su codigo en la base de datos.
*Entradas: int
*Salidas: UsuarioEntidad
*/
//#Metodo: consultarUsuarioPorCodigo
public UsuarioEntidad consultarUsuarioPorCodigo(int cod_usuario)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
return mapearUsuarioDeEfAEntidades(contexto.Usuario.Find(cod_usuario));
}
}
/*
*Propósito: Permite crear un registro en la tabla Auditoria a la base de datos.
*Entradas: AuditoriaEntidad
*Salidas: Auditoria
*/
//#Metodo: crearAuditoria
public Auditoria crearAuditoria(AuditoriaEntidad auditoria)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//pedidos.Estado = "creado";
Auditoria aud = new Auditoria();
aud = mapearAuditoriaDeEntidadesAEF(auditoria);
contexto.Auditoria.Add(aud);
contexto.SaveChanges();
return aud;
}
}
/*
*Propósito: Permite crear un pedido a la base de datos.
*Entradas: PedidoEntidad
*Salidas: Pedido
*/
//#Metodo: crearPedido
public Pedido crearPedido(PedidoEntidad pedidos)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//pedidos.Estado = "creado";
Pedido ped = new Pedido();
ped = mapearPedidoDeEntidadesAEf(pedidos);
foreach (var productoPedido in pedidos.PedidoProducto)
{
var pro = contexto.Producto.Where(p => p.cod_producto == productoPedido.CodProducto).FirstOrDefault();
if (pro != null)
{
pro.cantidad = pro.cantidad - productoPedido.Cantidad;
}
}
contexto.Pedido.Add(ped);
contexto.SaveChanges();
return ped;
}
}
/*
*Propósito: Permite crear un negocio en la base de datos.
*Entradas: NegocioEntidad
*Salidas: Negocio
*/
//#Metodo: crearNegocio
public Negocio crearNegocio(NegocioEntidad negocio)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
Negocio neg = new Negocio();
neg = mapearNegocioDeEntidadesAef(negocio);
contexto.Negocio.Add(neg);
contexto.SaveChanges();
return neg;
}
}
/*
*Propósito: Permite consultar el ultimo negocio presente en la BD.
*Entradas:
*Salidas: NegocioEntidad
*/
//#Metodo: ultimoNegocio
public NegocioEntidad ultimoNegocio()
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
NegocioEntidad neg = new NegocioEntidad();
neg = mapearNegocioDeEfAEntidades(contexto.Negocio.OrderByDescending(n => n.cod_negocio).FirstOrDefault());
return neg;
}
}
//******ENTREA2EDWIN******
/*
*Propósito: Permite consultar los productos con codigo mayor a codigoUltimoProducto.
*Entradas: codigoUltimoProducto
*Salidas: ObservableCollection<ProductoEntidad>
*/
//#Metodo: consultarNuevosProductos
public ObservableCollection<ProductoEntidad> consultarNuevosProductos(int codigoUltimoProducto)
{
ObservableCollection<ProductoEntidad> respuesta = new ObservableCollection<ProductoEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var nuevosProductos = from pro in contexto.Producto
where pro.cod_producto > codigoUltimoProducto
select pro;
//mapeo lo que me devuelve la base de datos a entidades
foreach (var item in nuevosProductos)
{
ProductoEntidad actual = mapearProductoDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar los pedidos con estado igual a creado, es decir
*pedidos que no se ha sincronizado.
*Entradas:
*Salidas: ObservableCollection<PedidoEntidad>
*/
//#Metodo: consultarNuevosPedidos
public ObservableCollection<PedidoEntidad> consultarNuevosPedidos()
{
ObservableCollection<PedidoEntidad> respuesta = new ObservableCollection<PedidoEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var nuevosPedidos = from ped in contexto.Pedido
where ped.estado == "creado"
select ped;
//mapeo lo que me devuelve la base de datos a entidades
foreach (var item in nuevosPedidos)
{
PedidoEntidad actual = mapearPedidoDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar la cantidad de pedidos por cada categoria en un intervalo de tiempo
*Entradas: DateTime, DateTime
*Salidas: List<string>
*/
//#Metodo: consultarCantidadPedidoPorCategoria
public List<string> consultarCantidadPedidoPorCategoria(DateTime inicio, DateTime fin)
{
List<string> respuesta = new List<string>();
DateTime fechaDiaDepuesFin = fin.AddDays(1);
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var cantidadPedidosPorCategoria = from ped in contexto.PedidoProducto
where ped.Pedido.fecha >= inicio.Date
&& ped.Pedido.fecha < fechaDiaDepuesFin
group ped by new
{
codCategoria = ped.Producto.Categoria_Producto.cod_cat_producto,
nombreCategoria = ped.Producto.Categoria_Producto.nombre_cat_producto
}
into grupo
orderby grupo.Count() descending
select new { key = grupo.Key, cnt = grupo.Count() };
foreach (var categoria in cantidadPedidosPorCategoria)
{
respuesta.Add(categoria.key.codCategoria.ToString());
respuesta.Add(categoria.key.nombreCategoria);
respuesta.Add(categoria.cnt.ToString());
}
return respuesta;
}
}
/*
*Propósito: Permite consultar la cantidad de pedidos hechos por ciudad en un intervalo de tiempo
*Entradas: DateTime, DateTime
*Salidas: List<string>
*/
//#Metodo: consultarCantidadPedidosPorCiudad
public List<String> consultarCantidadPedidosPorCiudad(DateTime inicio, DateTime fin)
{
List<string> respuesta = new List<string>();
DateTime fechaDiaDepuesFin = fin.AddDays(1);
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var pedidosCiudad = from ped in contexto.Pedido
where ped.fecha >= inicio.Date
&& ped.fecha < fechaDiaDepuesFin.Date
group ped by ped.Negocio.ciudad into grupo
orderby grupo.Count() descending
select new { key = grupo.Key, cnt = grupo.Count()};
foreach(var ciudad in pedidosCiudad){
respuesta.Add(ciudad.key);
respuesta.Add(ciudad.cnt.ToString());
}
return respuesta;
}
}
/*
*Propósito: Permite consultar los vendedores que no han sincronizado en un día determinado.
*Entradas: DateTime
*Salidas: ObservableCollection<UsuarioEntidad>
*/
//#Metodo: consultarVendedoresNoSincronizados
public ObservableCollection<UsuarioEntidad> consultarVendedoresNoSincronizados(DateTime fecha)
{
ObservableCollection<UsuarioEntidad> respuesta = new ObservableCollection<UsuarioEntidad>();
DateTime fechaUnDiaDespues = fecha.Date.AddDays(1);
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
var usuarios = from usuNosin in contexto.Usuario
where
usuNosin.cod_perfil == 2 &&
!(from usuSin in contexto.Auditoria
where usuSin.fecha >= fecha.Date && usuSin.fecha < fechaUnDiaDespues
select usuSin.cod_usuario)
.Contains(usuNosin.cod_usuario)
select usuNosin;
foreach (var item in usuarios)
{
UsuarioEntidad actual = mapearUsuarioDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar la cantidad de pedidos por cada producto en un intervalo de tiempo
*Entradas: DateTime, DateTime
*Salidas: List<string>
*/
//#Metodo: consultarCantidadPedidoPorProducto
public List<string> consultarCantidadPedidoPorProducto(DateTime inicio, DateTime fin)
{
List<string> respuesta = new List<string>();
DateTime fechaUnDiaDespuesFin = fin.Date.AddDays(1);
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var cantidadPedidosPorPorducto = from ped in contexto.PedidoProducto
where ped.Pedido.fecha >= inicio.Date
&& ped.Pedido.fecha < fechaUnDiaDespuesFin.Date
group ped by new
{
codProducto = ped.Producto.cod_producto,
nombreProducto = ped.Producto.nombre_producto,
cantidadPedidad = ped.Producto.cantidad
}
into grupo
orderby grupo.Sum(p => p.cantidad) descending
select new
{
key = grupo.Key, cnt = grupo.Sum(p => p.cantidad)
};
foreach (var producto in cantidadPedidosPorPorducto)
{
respuesta.Add(producto.key.codProducto.ToString());
respuesta.Add(producto.key.nombreProducto);
respuesta.Add(producto.cnt.ToString());
}
return respuesta;
}
}
/*
*Propósito: Permite consultar el inventario (cantidad diposnible) de los pruductos.
*Entradas:
*Salidas: ObservableCollection<ProductoEntidad>
*/
//#Metodo: consultarInventario
public ObservableCollection<ProductoEntidad> consultarInventario()
{
ObservableCollection<ProductoEntidad> respuesta = new ObservableCollection<ProductoEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var inventario = from inv in contexto.Producto
select inv;
//mapeo lo que me devuelve la base de datos a entidades
foreach (var item in inventario)
{
ProductoEntidad actual = mapearProductoDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar un producto por su codigo en la base de datos.
*Entradas: int
*Salidas: ProductoEntidad
*/
//#Metodo: consultarProductoPorCodigo
public ProductoEntidad consultarProductoPorCodigo(int cod_producto)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
return mapearProductoDeEfAEntidades(contexto.Producto.Find(cod_producto));
}
}
/*
*Propósito: Permite consultar un pedido por el nombre de un negocio a la base de datos.
*Entradas: NegocioEntidad
*Salidas: ObservableCollection<PedidoEntidad>
*/
//#Metodo: consultarPedidoPorNegocio
public ObservableCollection<PedidoEntidad> consultarPedidoPorNegocio(NegocioEntidad negocio)
{
ObservableCollection<PedidoEntidad> respuesta = new ObservableCollection<PedidoEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var pedidosNegocio = from ped in contexto.Pedido
where ped.Negocio.cod_negocio == negocio.CodNegocio
select ped;
//mapeo lo que me devuelve la base de datos a entidades
foreach (var item in pedidosNegocio)
{
PedidoEntidad actual = mapearPedidoDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar un vendedor por su codigo a la base de datos.
*Entradas: int cod_usuario
*Salidas: ObservableCollection<UsuarioEntidad>
*/
//#Metodo: consultarVendedorPorCodigo
public ObservableCollection<UsuarioEntidad> consultarVendedorPorCodigo(int cod_usuario)
{
ObservableCollection<UsuarioEntidad> respuesta = new ObservableCollection<UsuarioEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
var vendedor = from pro in contexto.Usuario
where pro.cod_usuario == cod_usuario
select pro;
foreach (var item in vendedor)
{
UsuarioEntidad actual = mapearUsuarioDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar la cantidad de pedidos hechos para una ciudad en un intervalo de tiempo
*Entradas: DateTime, DateTime
*Salidas: List<string>
*/
//#Metodo: consultarPedidoDeUnaCiudad
public ObservableCollection<PedidoEntidad> consultarPedidoDeUnaCiudad(string ciudad, DateTime inicio, DateTime fin)
{
ObservableCollection<PedidoEntidad> respuesta = new ObservableCollection<PedidoEntidad>();
DateTime fechaDiaDepuesFin = fin.AddDays(1);
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var pedidosCiudad = from ped in contexto.Pedido
where ped.Negocio.ciudad == ciudad &&
ped.fecha >= inicio.Date
&& ped.fecha < fechaDiaDepuesFin
select ped;
//mapeo lo que me devuelve la base de datos a entidades
foreach (var item in pedidosCiudad)
{
PedidoEntidad actual = mapearPedidoDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite listar las categorias que exisen en la base de datos.
*Entradas:
*Salidas: ObservableCollection<Categoria_ProductoEntidad>
*/
//#Metodo: listarCategorias
public ObservableCollection<Categoria_ProductoEntidad> listarCategorias()
{
ObservableCollection<Categoria_ProductoEntidad> respuesta = new ObservableCollection<Categoria_ProductoEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
var categorias = from cat in contexto.Categoria_Producto
select cat;
foreach (var item in categorias)
{
Categoria_ProductoEntidad actual = mapearCategoriaProductoDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite crear una categoria en la base de datos.
*Entradas: Categoria_ProductoEntidad
*Salidas: Producto
*/
//#Metodo: crearCategoriaProducto
public Categoria_Producto crearCategoriaProducto(Categoria_ProductoEntidad categoria)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
Categoria_Producto cat = new Categoria_Producto();
cat = mapearCategoriaProductoDeEntidadesAeF(categoria);
contexto.Categoria_Producto.Add(cat);
contexto.SaveChanges();
return cat;
}
}
/*
*Propósito: Permite consultar los negocios con codigo mayor a codigoUltimoNegocio.
*Entradas: codigoUltimoNegocio
*Salidas: ObservableCollection<NegocioEntidad>
*/
//#Metodo: consultarNuevosNegocios
public ObservableCollection<NegocioEntidad> consultarNuevosNegocios(int codigoUltimoNegocio)
{
ObservableCollection<NegocioEntidad> respuesta = new ObservableCollection<NegocioEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var nuevosNegocios = from neg in contexto.Negocio
where neg.cod_negocio > codigoUltimoNegocio
select neg;
//mapeo lo que me devuelve la base de datos a entidades
foreach (var item in nuevosNegocios)
{
NegocioEntidad actual = mapearNegocioDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite modificar los datos un categoria de producto en la base de datos
*Entradas: Categoria_ProductoEntidad
*Salidas:
*/
//#Metodo: editarCategoria_ProductoEntidad
public void editarCategoria_ProductoEntidad(Categoria_ProductoEntidad categoria)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
var cat = contexto.Categoria_Producto.Where(c => c.cod_cat_producto
== categoria.CodCatProducto).FirstOrDefault();
if (cat != null)
{
cat.nombre_cat_producto = categoria.NombreCatProducto;
contexto.SaveChanges();
}
}
}
/*
*Propósito: Permite crear un producto en la base de datos.
*Entradas: ProductoEntidad
*Salidas: Producto
*/
//#Metodo: crearProducto
public Producto crearProducto(ProductoEntidad producto)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
Producto pro = new Producto();
pro = mapearProductoDeEntidadesAef(producto);
contexto.Producto.Add(pro);
contexto.SaveChanges();
return pro;
}
}
/*
*Propósito: Permite consultar un negocio por su nombre a la base de datos.
*Entradas: string nombre_negocio
*Salidas: ObservableCollection<NegocioEntidad>
*/
//#Metodo: consultarNegocioPorNombre
public ObservableCollection<NegocioEntidad> consultarNegocioPorNombre(string nombre_negocio)
{
ObservableCollection<NegocioEntidad> respuesta = new ObservableCollection<NegocioEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
var almacen = from neg in contexto.Negocio
where neg.nombre_negocio.Contains(nombre_negocio)
select neg;
foreach (var item in almacen)
{
NegocioEntidad actual = mapearNegocioDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar el ultimo producto presente en la BD.
*Entradas:
*Salidas: ProductoEntidad
*/
//#Metodo: ultimoProducto
public ProductoEntidad ultimoProducto()
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
ProductoEntidad pro = new ProductoEntidad();
pro = mapearProductoDeEfAEntidades(contexto.Producto.OrderByDescending(p => p.cod_producto).FirstOrDefault());
return pro;
}
}
/*
*Propósito: Permite consultar la cantidad de pedidos hechos por dias de la semana
*Entradas: DateTime, DateTime
*Salidas: List<string>
*/
//#Metodo: consultarCantidadPedidosPorDiasSemana
public List<String> consultarCantidadPedidosPorDiasSemana(DateTime inicio, DateTime fin)
{
List<string> respuesta = new List<string>();
DateTime fechaDiaDepuesFin = fin.AddDays(1);
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var pedidosCiudad = from ped in contexto.Pedido
where ped.fecha >= inicio.Date
&& ped.fecha < fechaDiaDepuesFin.Date
group ped by SqlFunctions.DatePart("weekday", ped.fecha) into grupo
orderby grupo.Count() descending
select new { key = grupo.Key, cnt = grupo.Count() };
string[] dias = new string[7] { "Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado" };
foreach (var ciudad in pedidosCiudad)
{
respuesta.Add(dias[(int)ciudad.key - 1]);
respuesta.Add(ciudad.cnt.ToString());
}
return respuesta;
}
}
/*
*Propósito: Permite modificar el estado de un pedido en la BD
*Entradas:
*Salidas: PedidoEntidad
*/
//#Metodo: cambiarEstadoPedido
public void cambiarEstadoPedido(PedidoEntidad pedido)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
var ped = contexto.Pedido.Where(p => p.cod_pedido == pedido.CodPedido).FirstOrDefault();
if (ped != null)
{
ped.estado = pedido.Estado;
contexto.SaveChanges();
}
}
}
/*
*Propósito: Permite consultar una ctaegoria de producto por su codigo en la base de datos.
*Entradas: int
*Salidas: Categoria_ProductoEntidad
*/
//#Metodo: consultarCategoriaPorCodigo
public Categoria_ProductoEntidad consultarCategoriaPorCodigo(int cod_categoria)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
return mapearCategoriaProductoDeEfAEntidades(contexto.Categoria_Producto.Find(cod_categoria));
}
}
/*
*Propósito: Permite sber si se ha ralizado una sincrnizacio en la fecha dada
*Entradas: DateTime
*Salidas: bool
*/
//#Metodo: haSincronizadoEnEstaFecha
public bool haSincronizadoEnEstaFecha(DateTime fecha){
DateTime fechaUndiaDepues = fecha.Date.AddDays(1);
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var auditorias = from aud in contexto.Auditoria
where aud.fecha >= fecha.Date && aud.fecha < fechaUndiaDepues
select aud;
int res = auditorias.Count();
return auditorias.Count() != 0;
}
}
/*
*Propósito: Permite consultar un producto por nombre y categoria a la base de datos.
*Entradas: Categoria_ProductoEntidad categoria, string nombre_producto
*Salidas: ObservableCollection<ProductoEntidad>
*/
//#Metodo: consultarProductoPorNombreYCategoria
public ObservableCollection<ProductoEntidad> consultarProductoPorNombreYCategoria(string nombreCategoria, string nombre_producto)
{
ObservableCollection<ProductoEntidad> respuesta = new ObservableCollection<ProductoEntidad>();
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
var producto = from pro in contexto.Producto
where pro.nombre_producto.Contains(nombre_producto )
&& pro.Categoria_Producto.nombre_cat_producto == nombreCategoria
select pro;
foreach (var item in producto)
{
ProductoEntidad actual = mapearProductoDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar los pedidos que se han realizado en una fecha espcifica
*Entradas: DateTime
*Salidas: ObservableCollection<PedidoEntidad>
*/
//#Metodo: consultarPedidoPorFecha
public ObservableCollection<PedidoEntidad> consultarPedidoPorFecha(DateTime fecha){
ObservableCollection<PedidoEntidad> respuesta = new ObservableCollection<PedidoEntidad>();
DateTime fechaUnDiaDespues = fecha.Date.AddDays(1);
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
//los traigo de la base de datos
var pedidos = from ped in contexto.Pedido
where ped.fecha >= fecha.Date && ped.fecha < fechaUnDiaDespues
select ped;
//mapeo lo que me devuelve la base de datos a entidades
foreach (var item in pedidos)
{
PedidoEntidad actual = mapearPedidoDeEfAEntidades(item);
respuesta.Add(actual);
}
}
return respuesta;
}
/*
*Propósito: Permite consultar un pefil por su codigo en la base de datos.
*Entradas: int
*Salidas: PerfilEntidad
*/
//#Metodo: consultarPerfilPorCodigo
public PerfilEntidad consultarPerfilPorCodigo(int cod_perfil)
{
using (Sistema_ventasEntities contexto = new Sistema_ventasEntities())
{
return mapearPerfilDeEfAEntidades(contexto.Perfil.Find(cod_perfil));
}
}
