public async Task <IActionResult> ObtenerTodosHorariosEfectivos([FromBody] VMGeneral vMGeneral)
        {
            if (vMGeneral != null)
            {
                List <IngresoDiarioDTO> ingresos = await ingresoDiarioRepositorio.ObtenerTodosHorariosEfectivos(vMGeneral);

                if (ingresos == null)
                {
                    return(BadRequest());
                }
                List <IngresoDiarioxProveedor> ingXProveedor = ingresos
                                                               .GroupBy(g => g.Proveedor.Id)
                                                               .Select(s => new IngresoDiarioxProveedor()
                {
                    ProveedorId     = s.Key,
                    IngresosDiarios = s.OrderBy(o => o.Fecha).ToList()
                }).ToList();

                return(Ok(ingXProveedor));
            }
            else
            {
                List <IngresoDiarioDTO> ingresos = new List <IngresoDiarioDTO>();
                return(Ok(ingresos));
            }
        }
 public async Task <List <IngresoDiarioDTO> > ObtenerTodosHorariosEfectivos(VMGeneral vMGeneral)
 {
     try
     {
         List <IngresoDiario> ingresosDiarios;
         if (vMGeneral.ProveedorId > 0)
         {
             ingresosDiarios = db.IngresosDiarios
                               .Include(i => i.Funcionario)
                               .Include(n => n.Proveedor)
                               .Where(c => c.Fecha.Date >= vMGeneral.FechaActual.Date &&
                                      c.Fecha.Date <= vMGeneral.FechaFin.Date &&
                                      c.Proveedor.Id == vMGeneral.ProveedorId &&
                                      (c.EntradaEfectiva != null ||
                                       c.SalidaEfectiva != null)).ToList();
         }
         else
         {
             ingresosDiarios = db.IngresosDiarios
                               .Include(i => i.Funcionario)
                               .Include(n => n.Proveedor)
                               .Where(c => c.Fecha.Date >= vMGeneral.FechaActual.Date &&
                                      c.Fecha.Date <= vMGeneral.FechaFin.Date &&
                                      (c.EntradaEfectiva != null ||
                                       c.SalidaEfectiva != null)).ToList();
         }
         List <IngresoDiarioDTO> ingsDiariosDTO = mapper.Map <List <IngresoDiario>, List <IngresoDiarioDTO> >(ingresosDiarios);
         return(ingsDiariosDTO);
     }
     catch (Exception e)
     {
         return(null);
     }
 }
        public async Task <IActionResult> IngresosDiariosSinMarcaciones([FromBody] VMGeneral fechaActual)
        {
            if (fechaActual.FechaActual <= DateTime.Today.Date)
            {
                List <IngresoDiarioDTO> ingresos = await ingresoDiarioRepositorio.ObtenerSinMarcaciones(fechaActual.FechaActual);

                if (ingresos == null)
                {
                    return(BadRequest());
                }
                List <IngresoDiarioxProveedor> ingXProveedor = ingresos
                                                               .GroupBy(g => g.Proveedor.Id)
                                                               .Select(s => new IngresoDiarioxProveedor()
                {
                    ProveedorId     = s.Key,
                    IngresosDiarios = s.ToList()
                }).ToList();

                return(Ok(ingXProveedor));
            }
            else
            {
                List <IngresoDiarioDTO> ingresos = new List <IngresoDiarioDTO>();
                return(Ok(ingresos));
            }
        }
 public async Task <List <TerciarizacionDTO> > ObtenerTodos(VMGeneral vmFecha)
 {
     try
     {
         List <TerciarizacionDTO> terciariza = mapper.Map <List <Terciarizacion>, List <TerciarizacionDTO> >
                                                   (db.Terciarizaciones.Include(i => i.Proveedor)
                                                   .Where(w => w.Fecha.Month == vmFecha.FechaActual.Month && w.Fecha.Year == vmFecha.FechaActual.Year)
                                                   .OrderBy(o => o.Proveedor.RazonSocial)
                                                   .ToList());
         return(terciariza);
     }
     catch (Exception e)
     {
         return(null);
     }
 }
        public async Task <List <TerciarizacionDTO> > ObtenerTodosXProveedor(VMGeneral vmGeneral)
        {
            var response = await httpClient.PostAsJsonAsync("/api/Terciarizacion/ObtenerTodosXProveedor", vmGeneral);

            if (response.IsSuccessStatusCode)
            {
                var content = await response.Content.ReadAsStringAsync();

                var todos = JsonConvert.DeserializeObject <List <TerciarizacionDTO> >(content);
                return(todos);
            }
            else
            {
                return(null);
            }
        }
 public async Task <List <TerciarizacionDTO> > ObtenerTodosXProveedor(VMGeneral vmGeneral)
 { //proveedorId,fecha inicio y fecha fin
     try
     {
         List <TerciarizacionDTO> terc = mapper.Map <List <Terciarizacion>, List <TerciarizacionDTO> >
                                             (db.Terciarizaciones.Include(i => i.Proveedor)
                                             .Where(p => p.Proveedor.Id == vmGeneral.ProveedorId)
                                             .OrderByDescending(o => o.Fecha)
                                             .Take(24)
                                             .ToList());
         return(terc);
     }
     catch (Exception e)
     {
         return(null);
     }
 }
        public async Task <IActionResult> ObtenerTodosXProveedorOperador([FromBody] VMGeneral vmGeneral)
        {
            if (vmGeneral != null)
            {
                //nuevo funcionario
                var resultado = await terciarizacionRepositorio.ObtenerTodosXProveedorOperador(vmGeneral);

                if (resultado == null)
                {
                    return(BadRequest());
                }
                return(Ok(resultado));
            }
            else
            {
                return(BadRequest());
            }
        }
Exemple #8
0
        public async Task <List <IngresoDiarioxProveedor> > ObtenerSinMarcaciones(VMGeneral fechaActual)
        {
            if (fechaActual != null)
            {
                var response = await httpClient.PostAsJsonAsync("/api/IngresoDiario/sinMarca", fechaActual);

                if (response.IsSuccessStatusCode)
                {
                    var content = await response.Content.ReadAsStringAsync();

                    var ingDiariosXPRoveedorDTO = JsonConvert.DeserializeObject <List <IngresoDiarioxProveedor> >(content);
                    return(ingDiariosXPRoveedorDTO);
                }
                else
                {
                    return(null);
                }
            }
            else
            {
                return(null);
            }
        }
Exemple #9
0
        public async Task <List <IngresoDiarioxProveedor> > ObtenerReporteHorariosPlanificados(VMGeneral vmGeneral)
        {
            if (vmGeneral != null)
            {
                var response = await httpClient.PostAsJsonAsync("/api/IngresoDiario/ReporteHorariosPlanificados", vmGeneral);

                if (response.IsSuccessStatusCode)
                {
                    var content = await response.Content.ReadAsStringAsync();

                    var ingDiariosXPRoveedorDTO = JsonConvert.DeserializeObject <List <IngresoDiarioxProveedor> >(content);
                    return(ingDiariosXPRoveedorDTO);
                }
                else
                {
                    return(null);
                }
            }
            else
            {
                return(null);
            }
        }