public async Task <List <citaModel> > obtenerCitasPorEmpleado(DateTime from, DateTime to, int empleadoId)
{
using (var db = new estetica_lupitaEntities())
{
var query = await(from cita in db.citas.Where(c =>
c.ct_fecha >= @from &&
c.ct_fecha <= @to
)
join empleado in db.empleados on cita.ct_empleado equals empleado.idempleado
join cliente in db.clientes on cita.ct_cliente equals cliente.idcliente
where cita.ct_estatus != 0 && empleado.idempleado == empleadoId
select new citaModel
{
Id = cita.idcita,
Fecha = cita.ct_fecha,
Hora = cita.ct_hora,
NombreCliente = cliente.cl_nombrecompleto,
NombreEmpleado = empleado.emp_nombrecompleto,
}).ToListAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener Todas las citas del empleado {query[0].NombreEmpleado}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(query.OrderByDescending(o => o.Id).ToList());
}
}
public async Task <FullVenta> crearNueva(notaventa nota, List <notaventa_detalle> detalle)
{
using (var db = new estetica_lupitaEntities())
{
var notaventa = db.notaventa.Add(nota);
await db.SaveChangesAsync();
detalle.ForEach(d =>
d.idnotaventa = notaventa.idnotaventa
);
db.notaventa_detalle.AddRange(detalle);
await db.SaveChangesAsync();
var newNota = await obtenerPorId(notaventa.idnotaventa);
var ctCtrl = new citaController();
await ctCtrl.cambiarEstadoDeCita(notaventa.nv_cita, 3);
await auditCtrl.auditar(new auditorias
{
descripcion = $"Crear una nueva venta con folio {notaventa.idnotaventa}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(newNota);
}
}
public async Task <List <citaModel> > obtenerCitasSatisfactorias()
{
using (var db = new estetica_lupitaEntities())
{
var query = await(from cita in db.citas.Where(c => c.ct_estatus == 3)
join empleado in db.empleados on cita.ct_empleado equals empleado.idempleado
join cliente in db.clientes on cita.ct_cliente equals cliente.idcliente
select new citaModel
{
Id = cita.idcita,
Fecha = cita.ct_fecha,
Hora = cita.ct_hora,
NombreCliente = cliente.cl_nombrecompleto,
NombreEmpleado = empleado.emp_nombrecompleto,
}).ToListAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener citas satisfactorias",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(query);
}
}
public async Task <citaModel> obtenerCitaPorId(int citaId)
{
using (var db = new estetica_lupitaEntities())
{
var query = await(from cita in db.citas.Where(c => c.idcita == citaId)
join empleado in db.empleados on cita.ct_empleado equals empleado.idempleado
join cliente in db.clientes on cita.ct_cliente equals cliente.idcliente
where cita.ct_estatus != 0 && cita.ct_estatus != 3
select new citaModel
{
Id = cita.idcita,
Fecha = cita.ct_fecha,
Hora = cita.ct_hora,
NombreCliente = cliente.cl_nombrecompleto,
NombreEmpleado = empleado.emp_nombrecompleto,
}).FirstOrDefaultAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener una cita completa con folio {citaId}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(query);
}
}
public async Task <List <empleadoModel> > obtenerTodos()
{
using (var db = new estetica_lupitaEntities())
{
var empleados = await(from empleado in db.empleados.Take(100)
join puesto in db.puestos on empleado.emp_puesto equals puesto.idpuesto
select new empleadoModel
{
Id = empleado.idempleado,
NombreCompleto = empleado.emp_nombrecompleto,
Puesto = puesto.pst_descripcion,
Sueldo = empleado.emp_sueldo,
Telefono = empleado.emp_telefono,
Estatus = empleado.emp_estatus
}).ToListAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener Todos los empleados",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(empleados
.OrderByDescending(o => o.Id)
.ToList()
.Where(f => f.Estatus != 0)
.ToList());
}
}
public async Task <empleadoModel> obtenerPorId(int empleadoId)
{
using (var db = new estetica_lupitaEntities())
{
var query = await(from empleado in db.empleados.Where(c => c.idempleado == empleadoId)
join puesto in db.puestos on empleado.emp_puesto equals puesto.idpuesto
select new empleadoModel
{
Id = empleado.idempleado,
NombreCompleto = empleado.emp_nombrecompleto,
Puesto = puesto.pst_descripcion,
Sueldo = empleado.emp_sueldo,
Telefono = empleado.emp_telefono,
Estatus = empleado.emp_estatus
}).ToListAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener empleado por su id {empleadoId}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(query[0]);
}
}
public async Task <clientes> verificarNombre(String clienteNombre)
{
using (var db = new estetica_lupitaEntities())
{
var cliente = await db.clientes.FirstOrDefaultAsync(c => c.cl_nombrecompleto == clienteNombre);
return(cliente);
}
}
public async Task <usuarios> obtenerPorId(int usuarioId)
{
using (var db = new estetica_lupitaEntities())
{
var user = await db.usuarios.FirstAsync(u => u.idusuario == usuarioId);
return(user);
}
}
public async Task <auditorias> auditar(auditorias auditoria)
{
using (var db = new estetica_lupitaEntities())
{
db.auditorias.Add(auditoria);
await db.SaveChangesAsync();
return(auditoria);
}
}
public async Task <bool> depurar()
{
using (var db = new estetica_lupitaEntities())
{
var allAudits = await(from c in db.auditorias select c).ToListAsync();
db.auditorias.RemoveRange(allAudits);
var rows = await db.SaveChangesAsync();
return(rows > 0);
}
}
public async Task <usuarios> verificarExistencia(String nombreUsuario)
{
using (var db = new estetica_lupitaEntities())
{
var user = await db.usuarios.FirstOrDefaultAsync(u =>
u.usuario_name == nombreUsuario
);
return(user != null ? user : null);
}
}
public async Task <servicios> verificarNombre(string servicioNombre)
{
using (var db = new estetica_lupitaEntities())
{
var servicio = await db.servicios.FirstOrDefaultAsync(f =>
f.sv_descripcion == servicioNombre &&
f.sv_estatus != 0
);
return(servicio);
}
}
public async Task <List <auditorias> > obtenerAuditoriasPorFecha(DateTime fromt, DateTime to)
{
using (var db = new estetica_lupitaEntities())
{
var auditorias = await db.auditorias.Where(c =>
c.fecha >= fromt &&
c.fecha <= to
).ToListAsync();
return(auditorias);
}
}
public async Task <puestos> verificarNombre(String puestoNombre)
{
using (var db = new estetica_lupitaEntities())
{
var puesto = await db.puestos.FirstOrDefaultAsync(f =>
f.pst_descripcion == puestoNombre &&
f.pst_estatus != 0
);
return(puesto);
}
}
public async Task <empleados> verificarNombre(String empleadoNombre)
{
using (var db = new estetica_lupitaEntities())
{
var emp = await db.empleados.FirstOrDefaultAsync(f =>
f.emp_nombrecompleto == empleadoNombre &&
f.emp_estatus != 0
);
return(emp);
}
}
public async Task <List <auditorias> > obtenerAuditoriasPorUsuario(string nombreUsuario, DateTime fromt, DateTime to)
{
using (var db = new estetica_lupitaEntities())
{
var auditorias = await db.auditorias.Where(u =>
u.usuario == nombreUsuario &&
u.fecha >= fromt &&
u.fecha <= to
).ToListAsync();
return(auditorias);
}
}
public async Task <List <clientes> > getclienteByNameMatching(String text)
{
using (var db = new estetica_lupitaEntities())
{
var empleados = await db.clientes.Where(d => d.cl_nombrecompleto.Contains(text)).ToListAsync();
return(empleados
.OrderByDescending(o => o.idcliente)
.ToList()
.Where(f => f.cl_estatus != 0)
.ToList());
}
}
public async Task <List <FullVenta> > obtenerPorFechas(DateTime fromt, DateTime to)
{
using (var db = new estetica_lupitaEntities())
{
var query = await(from notaventa in db.notaventa
join cita in db.citas on notaventa.nv_cita equals cita.idcita
join cliente in db.clientes on notaventa.nv_cliente equals cliente.idcliente
join empleado in db.empleados on notaventa.nv_cliente equals empleado.idempleado
where cita.ct_fecha >= fromt && cita.ct_fecha <= to
select new notaventaModel
{
Id = notaventa.idnotaventa,
Cita = cita.idcita,
Cliente = cliente.cl_nombrecompleto,
Empleado = empleado.emp_nombrecompleto,
Total = notaventa.nv_total,
Estatus = notaventa.nv_estatus,
}).ToListAsync();
var detalles = await(from nvd in db.notaventa_detalle
join servicio in db.servicios on nvd.nvd_servicio equals servicio.idservicio
select new notaventaDetalleModel
{
Id = nvd.idnotaventa,
Servicio = servicio.sv_descripcion,
Precio = nvd.nvd_precio,
Cantidad = nvd.nvd_cantidad
}).ToListAsync();
// Retornar lista de ventas con su lista de detalles
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener ventas entre fecha {fromt:d} y {to:d}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
var fv = query.Select(v => {
return(new FullVenta(
nota: v,
detalle: detalles.Where(d => d.Id == v.Id).ToList()));
}).ToList().OrderByDescending(o =>
o.NotaVenta.Id
).ToList();
return(fv);
}
}
public async Task <servicios> obtenerPorId(int servicioId)
{
using (var db = new estetica_lupitaEntities())
{
var servicio = await db.servicios.FirstOrDefaultAsync(c => c.idservicio == servicioId);
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener servicio por su id {servicioId}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(servicio);
}
}
public async Task <citas> obtenerCitaPorIdOriginal(int citaId)
{
using (var db = new estetica_lupitaEntities())
{
var cita = await db.citas.FirstOrDefaultAsync(c => c.idcita == citaId);
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener una cita completa con folio {citaId}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(cita);
}
}
public async Task <List <usuarios> > obtenerTodos()
{
using (var db = new estetica_lupitaEntities())
{
var usuarios = await db.usuarios.Take(100).ToListAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener todos los usuarios",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(usuarios.OrderByDescending(o => o.idusuario).ToList());
}
}
public async Task <puestos> obtenerPorId(int puestoId)
{
using (var db = new estetica_lupitaEntities())
{
var puesto = await db.puestos.FindAsync(puestoId);
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener puesto por su id {puestoId}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(puesto);
}
}
public async Task <clientes> obtenerPorId(int clienteId)
{
using (var db = new estetica_lupitaEntities())
{
var cliente = await db.clientes.FirstOrDefaultAsync(c => c.idcliente == clienteId);
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener cliente por su id {clienteId}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(cliente);
}
}
public async Task <puestos> actualizar(puestos puesto)
{
using (var db = new estetica_lupitaEntities())
{
var response = await db.puestos.FindAsync(puesto.idpuesto);
response.pst_descripcion = puesto.pst_descripcion;
await auditCtrl.auditar(new auditorias
{
descripcion = $"Actualizo el puesto {puesto.pst_descripcion}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(response);
}
}
public async Task <usuarios> crearNuevoUsuario(usuarios usuario)
{
using (var db = new estetica_lupitaEntities())
{
var newUser = db.usuarios.Add(usuario);
await db.SaveChangesAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Se creo un nuevo usuario {usuario.usuario_name}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(newUser);
}
}
public async Task <servicios> crearNuevo(servicios servicio)
{
using (var db = new estetica_lupitaEntities())
{
var response = db.servicios.Add(servicio);
await db.SaveChangesAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Crear servicio {servicio.sv_descripcion}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(response);
}
}
public async Task <clientes> crearNuevo(clientes cliente)
{
using (var db = new estetica_lupitaEntities())
{
var response = db.clientes.Add(cliente);
await db.SaveChangesAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Creo al cliente llamado {cliente.cl_nombrecompleto}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(response);
}
}
public async Task <empleados> crearNuevo(empleados empleado)
{
using (var db = new estetica_lupitaEntities())
{
var res = db.empleados.Add(empleado);
await db.SaveChangesAsync();
await auditCtrl.auditar(new auditorias
{
descripcion = $"Creo el empleado {empleado.emp_nombrecompleto}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(res);
}
}
public async Task <List <citaModel> > getcitaByFolioMatching(string folio)
{
using (var db = new estetica_lupitaEntities())
{
var query = await(from cita in db.citas
join empleado in db.empleados on cita.ct_empleado equals empleado.idempleado
join cliente in db.clientes on cita.ct_cliente equals cliente.idcliente
where cita.idcita.ToString().Contains(folio) && cita.ct_estatus != 0
select new citaModel
{
Id = cita.idcita,
Fecha = cita.ct_fecha,
Hora = cita.ct_hora,
NombreCliente = cliente.cl_nombrecompleto,
NombreEmpleado = empleado.emp_nombrecompleto,
}).ToListAsync();
return(query.OrderByDescending(o => o.Id).ToList());
}
}
public async Task <FullVenta> obtenerPorId(int notaventaId)
{
using (var db = new estetica_lupitaEntities())
{
var query = await(from notaventa in db.notaventa
join cita in db.citas on notaventa.nv_cita equals cita.idcita
join cliente in db.clientes on notaventa.nv_cliente equals cliente.idcliente
join empleado in db.empleados on notaventa.nv_cliente equals empleado.idempleado
where notaventa.idnotaventa == notaventaId
select new notaventaModel
{
Id = notaventa.idnotaventa,
Cita = cita.idcita,
Cliente = cliente.cl_nombrecompleto,
Empleado = empleado.emp_nombrecompleto,
Total = notaventa.nv_total,
Estatus = notaventa.nv_estatus,
}).FirstOrDefaultAsync();
var detalles = await(from nvd in db.notaventa_detalle
join servicio in db.servicios on nvd.nvd_servicio equals servicio.idservicio
where nvd.idnotaventa == notaventaId
select new notaventaDetalleModel
{
Id = nvd.idnotaventa,
Servicio = servicio.sv_descripcion,
Precio = nvd.nvd_precio,
Cantidad = nvd.nvd_cantidad
}).ToListAsync();
// Retornar venta con su lista de detalles
await auditCtrl.auditar(new auditorias
{
descripcion = $"Obtener una venta con id {notaventaId}",
fecha = DateTime.Now,
hora = DateTime.Now.TimeOfDay,
usuario = global.LoggedUser.usuario_name
});
return(new FullVenta(nota: query, detalle: detalles));
}
}
