public ActionResult CargaArchivoIncidenciaHistorico(CargaArchivoIncidenciaHistoricoFormModel Form)
        {
            CargaArchivoIncidenciaHistoricoViewModel model = new CargaArchivoIncidenciaHistoricoViewModel(Form);
            Dictionary<string, string> diccionario = DiccionarioCabecera.DiccionarioCabeceraIncidencia.GetDiccionarioIncidenciaHistorico();
            if (diccionario == null || (diccionario != null && !diccionario.Any()))
            {
                ModelState.AddModelError("Form.Archivo", "No se puede reconocer la estrucutra del archivo.");
            }

            if (ModelState.IsValid)
            {
                int largo = Form.Archivo.ContentLength;
                byte[] buffer = new byte[largo];
                Form.Archivo.InputStream.Read(buffer, 0, largo);
                using (MemoryStream ms = new MemoryStream(buffer))
                {
                    XSSFWorkbook libro = null;
                    var stream = Form.Archivo.InputStream;
                    try
                    {
                        libro = new XSSFWorkbook(ms);
                    }
                    catch
                    {
                        ModelState.AddModelError(String.Empty, "Formato de achivo incorrecto.");
                        return View(model);
                    }

                    List<IReglaValidacion> reglas = new List<IReglaValidacion>();
                    reglas.Add(new FechaCorrectaValidacion());
                    reglas.Add(new IncidenciaExisteValidacion());
                    reglas.Add(new Aufen.PortalReportes.Web.Models.ReglaValidacionModels.ReglaValidacionIncidenciaHistoricoModels.RutRequeridoValidacion());
                    reglas.Add(new Aufen.PortalReportes.Web.Models.ReglaValidacionModels.ReglaValidacionIncidenciaHistoricoModels.RutExisteValidacion());
                    reglas.Add(new TipoDiaExisteValidacion());
                    reglas.Add(new LlaveUnicaValidacion());
                    CargadorExcelGenerico cargador = new CargadorExcelGenerico(libro, diccionario, reglas);
                    cargador.ValidarEncabezado();

                    if (cargador.EsEncabezadoValido)
                    {
                        IEnumerable<IncidenciaHistoricoDTO> resultados =
                                cargador.CargarArchivo<IncidenciaHistoricoDTO>();
                        foreach (var resultado in resultados)
                        {
                            DateTime _fecha = DateTime.Parse(resultado.Fecha);
                            CALENDARIO01 calendario = new CALENDARIO01()
                            {
                                Fecha = _fecha.Year.ToString() + ("0" + _fecha.Month.ToString()).Right(2) + ("0" + _fecha.Day.ToString()).Right(2),
                                Publico = 0,
                                IdTipoDia = Convert.ToChar(resultado.IdTipoDia),
                                IdIncidencia = ("0000" + resultado.IdIncidencia).Right(4),
                                IdCalendario = ("000000000" + resultado.Rut).Right(9),
                            };

                            if(db.CALENDARIO01s.Any(x => x.Fecha == calendario.Fecha
                                && x.Publico == calendario.Publico
                                && x.IdCalendario == calendario.IdCalendario))
                            {
                                var cal = db.CALENDARIO01s.Single(x => x.Fecha == calendario.Fecha
                                    && x.Publico == calendario.Publico
                                    && x.IdCalendario == calendario.IdCalendario);
                                cal.IdTipoDia = calendario.IdTipoDia;
                                cal.IdIncidencia = calendario.IdIncidencia;
                                cal.Observaciones = cal.Observaciones + ".";
                            }
                            else
                            {
                                db.CALENDARIO01s.InsertOnSubmit(calendario);
                            }

                            db.SubmitChanges();
                        }

                        if (!cargador.EsArchivoValido)
                        {
                            MemoryStream salidaExcel = new MemoryStream();
                            var salida = cargador.GetSalida();
                            salida.Write(salidaExcel);
                            return File(salidaExcel.ToArray(),
                                "application/vnd.ms-excel",
                                "Errores_" + DateTime.Now.ToString("dd-MM-yyyy") + ".xlsx");
                        }
                    }
                    else
                    {
                        foreach (var item in cargador.GetErroresEncabezado)
                        {
                            ModelState.AddModelError(String.Empty, item);
                        }
                        return View(model);
                    }
                }
                Mensaje = "El proceso de carga ha finalizado exitosamente.";
                return RedirectToAction("ListarReporte", "Reportes");
            }
            Mensaje = "Ha ocurrido un problema con el proceso de carga.";
            return View(model);
        }
        public ActionResult CargaArchivoTurnoHistorico(CargaArchivoTurnoHistoricoFormModel Form)
        {
            int Mes;
            int Ano;
            if (String.IsNullOrWhiteSpace(Form.Periodo))
            {
                Mes = DateTime.Now.AddMonths(-1).Month;
                Ano = DateTime.Now.AddMonths(-1).Year;
            }
            else
            {
                LectorMonthPicker lector = new LectorMonthPicker(Form.Periodo);
                Mes = lector.GetMes;
                Ano = lector.GetAnno;
            }
            CargaArchivoTurnoHistoricoViewModel model = new CargaArchivoTurnoHistoricoViewModel(Form);
            Dictionary<string, string> diccionario = DiccionarioCabecera.DiccionarioCabeceraHistorico.GetDiccionarioTurnoHistorico();
            if (diccionario == null || (diccionario != null && !diccionario.Any()))
            {
                ModelState.AddModelError("Form.Archivo", "No se puede reconocer la estrucutra del archivo.");
            }

            if (ModelState.IsValid)
            {
                int largo = Form.Archivo.ContentLength;
                byte[] buffer = new byte[largo];
                Form.Archivo.InputStream.Read(buffer, 0, largo);
                using (MemoryStream ms = new MemoryStream(buffer))
                {
                    XSSFWorkbook libro = null;
                    var stream = Form.Archivo.InputStream;
                    try
                    {
                        libro = new XSSFWorkbook(ms);
                    }
                    catch
                    {
                        ModelState.AddModelError(String.Empty, "Formato de achivo incorrecto.");
                        return View(model);
                    }

                    List<IReglaValidacion> reglas = new List<IReglaValidacion>();
                    reglas.Add(new Aufen.PortalReportes.Web.Models.ReglaValidacionModels.ReglaValidacionTurnoHistoricoModels.RutRequeridoValidacion());
                    reglas.Add(new Aufen.PortalReportes.Web.Models.ReglaValidacionModels.ReglaValidacionTurnoHistoricoModels.RutExisteValidacion());
                    reglas.Add(new CalendarioRequeridoValidacion());
                    reglas.Add(new CalendarioExisteValidacion());
                    reglas.Add(new FechaDesdeFormatoValidacion(Mes, Ano));
                    reglas.Add(new FechaDesdeRequeridoValidacion());
                    reglas.Add(new FechaHastaFormatoValidacion(Mes, Ano));
                    reglas.Add(new HorarioExisteValidacion());
                    reglas.Add(new HorarioRequeridoValidacion());
                    reglas.Add(new FechaDesdeMenorFechaHastaValidacion());
                    CargadorExcelGenerico cargador = new CargadorExcelGenerico(libro, diccionario, reglas);
                    cargador.ValidarEncabezado();

                    if (cargador.EsEncabezadoValido)
                    {
                        IEnumerable<TurnoHistoricoDTO> resultados =
                                cargador.CargarArchivo<TurnoHistoricoDTO>();

                        foreach(var rut in resultados.GroupBy(x => x.Rut))
                        {
                            //  elimino todo lo del rut para el periodo y hacia adelante
                            db.sp_EliminaHistoricos(rut.Key, new DateTime(Ano, Mes, 1).AddDays(-1));
                        }

                        foreach (var resultado in resultados)
                        {
                            var empleado = db.Fn_DatosEmpleado(resultado.IdHorario, resultado.Rut, resultado.IdCalendario)
                                .FirstOrDefault();
                            if (empleado != null && resultado.FechaHastaAsDateTime.HasValue && resultado.FechaDesdeAsDateTime.HasValue)
                            {
                                var empleadoCalendarioHorariosHistorico01s = db.EmpleadoCalendarioHorariosHistorico01s
                                    .Where(x => x.CodigoEmpleado == empleado.CodigoEmpleado &&
                                    x.FechaDesde <= resultado.FechaHastaAsDateTime.Value &&
                                    (!x.FechaHasta.HasValue ||
                                        (x.FechaHasta.HasValue && x.FechaHasta.Value > resultado.FechaDesdeAsDateTime))
                                    ).ToList();// si existe el empleado deberia al menos tener un registro con ultima fecha null
                                // Elimino las antiguas pera no tener problemas
                                db.EmpleadoCalendarioHorariosHistorico01s.DeleteAllOnSubmit(empleadoCalendarioHorariosHistorico01s);
                                db.SubmitChanges();
                                // Ahora  omito las que quedan dentro del intervalo que quiero insertar desde el excel, es >= y <= ya que podria querer agregar el mismo registro y lo omito tambien para evitar duplicados
                                List<EmpleadoCalendarioHorariosHistorico01> insercion = empleadoCalendarioHorariosHistorico01s.Where(x=>!(
                                    x.FechaDesde >= resultado.FechaDesdeAsDateTime &&
                                    x.FechaHasta <= resultado.FechaHastaAsDateTime.Value))
                                    .ToList();
                                // Agrego el que quiero insertar desde el excel
                                insercion.Add(new EmpleadoCalendarioHorariosHistorico01()
                                {
                                    IdEmpleadoCalendarioHorariosHistorico01 = Guid.NewGuid(),
                                    CodigoEmpleado = empleado.CodigoEmpleado,
                                    CodigoHorario = ("0000" + resultado.IdHorario).Right(4),
                                    IdCalendario = resultado.IdCalendario,
                                    FechaCreacion = DateTime.Now,
                                    FechaDesde= resultado.FechaDesdeAsDateTime.Value,
                                    FechaHasta = resultado.FechaHastaAsDateTime.Value,
                                });
                                //Ordeno por Fecha desde
                                insercion = insercion.OrderByDescending(x=> x.FechaDesde).ToList();
                                // agrego el que tiene fecha hasta null
                                EmpleadoCalendarioHorariosHistorico01 bufferInsercion = insercion.First();
                                db.EmpleadoCalendarioHorariosHistorico01s.InsertOnSubmit(new EmpleadoCalendarioHorariosHistorico01() {
                                    IdEmpleadoCalendarioHorariosHistorico01 = Guid.NewGuid(),
                                    FechaHasta = null,
                                    FechaDesde = bufferInsercion.FechaDesde,
                                    FechaCreacion = bufferInsercion.FechaCreacion,
                                    CodigoEmpleado = bufferInsercion.CodigoEmpleado,
                                    IdCalendario = bufferInsercion.IdCalendario,
                                    CodigoHorario = ("0000" + bufferInsercion.CodigoHorario).Right(4),
                                    Donde = "Turno Historico"
                                });
                                foreach (var insertar in insercion.Skip(1))
                                {
                                    EmpleadoCalendarioHorariosHistorico01 bufferInsertar = new EmpleadoCalendarioHorariosHistorico01()
                                    {
                                        IdEmpleadoCalendarioHorariosHistorico01 = Guid.NewGuid(),
                                        FechaDesde = insertar.FechaDesde,
                                        FechaHasta = insertar.FechaHasta,
                                        FechaCreacion = insertar.FechaCreacion,
                                         CodigoEmpleado = insertar.CodigoEmpleado,
                                         IdCalendario = insertar.IdCalendario,
                                         CodigoHorario = ("0000" + insertar.CodigoHorario).Right(4),
                                         Donde = "Turno Historico"
                                    };
                                    // Me aseguro de conservar el intervalo proeniente del excel como corresponde
                                    if (bufferInsertar.FechaDesde > resultado.FechaDesdeAsDateTime.Value &&
                                        bufferInsertar.FechaDesde < resultado.FechaHastaAsDateTime.Value)
                                    {
                                        bufferInsertar.FechaDesde = resultado.FechaHastaAsDateTime.Value.AddDays(1);
                                    }
                                    // seteo la fecha hasta hasta el intervalo que viene adelante
                                    bufferInsertar.FechaHasta = bufferInsercion.FechaDesde.AddDays(-1);
                                    if (bufferInsertar.FechaHasta >= insertar.FechaDesde)
                                    {
                                        // porsiaca, para no insertar intervalos invalidos
                                        db.EmpleadoCalendarioHorariosHistorico01s.InsertOnSubmit(bufferInsertar);
                                    }
                                    bufferInsercion = insertar;
                                }
                            }
                            db.SubmitChanges();
                        }

                        if (!cargador.EsArchivoValido)
                        {
                            MemoryStream salidaExcel = new MemoryStream();
                            var salida = cargador.GetSalida();
                            salida.Write(salidaExcel);
                            return File(salidaExcel.ToArray(),
                                "application/vnd.ms-excel",
                                "Errores_" + DateTime.Now.ToString("dd-MM-yyyy") + ".xlsx");
                        }
                    }
                    else
                    {
                        foreach (var item in cargador.GetErroresEncabezado)
                        {
                            ModelState.AddModelError(String.Empty, item);
                        }
                        return View(model);
                    }
                }
                Mensaje = "El proceso de carga ha finalizado exitosamente.";
                return RedirectToAction("ListarReporte", "Reportes");
            }
            Mensaje = "Ha ocurrido un problema con el proceso de carga.";
            return View(model);
        }