public ActionResult ConfirmarBorrar(string id)
        {
            if (string.IsNullOrEmpty(id) || id == "-1")
                return MostrarAdvertencia("No se pudo cargar la informacion del casi accidente que desea eliminar.");

            var nid = long.Parse(id);
            var casiAccidente = db.CasiAccidente.FirstOrDefault(x => x.IdCasiAccidente == nid);

            if (casiAccidente == null)
                return MostrarAdvertencia("No se pudo cargar la informacion del casi accidente que desea eliminar.");

            var item = new CasiAccidenteModel();

            item.IdCasiAccidente = casiAccidente.IdCasiAccidente;
            item.Analisis = casiAccidente.Analisis;
            item.Condicion = casiAccidente.Condicion;
            item.PersonalApoyo = casiAccidente.PersonalApoyo;
            item.Peligro = casiAccidente.Peligro;
            item.OtraCondicion = casiAccidente.OtraCondicion;

            item.Fecha = casiAccidente.Fecha._ToDateTime().ToShortDateString();
            item.FechaCierre = casiAccidente.FechaCierre._ToDateTime().ToShortDateString();

            return View(item);
        }
        public ActionResult Eliminar(CasiAccidenteModel model)
        {
            try
            {

                if (model.IdCasiAccidente <= 0)
                    return MostrarAdvertencia("No se pudo cargar la informacion del casi accidente que desea eliminar.");

                var casiAccidente = db.CasiAccidente.FirstOrDefault(x => x.IdCasiAccidente == model.IdCasiAccidente);

                if (casiAccidente == null)
                    return MostrarAdvertencia("No se pudo cargar la informacion del casi accidente que desea eliminar.");

                var medidas = db.CasiAccidente_MedidaPrev.Where(x => x.IdCasiAccidente == model.IdCasiAccidente);
                if (medidas != null)
                {
                    var listamedidas = medidas.ToList();

                    while (listamedidas.Count > 0)
                    {
                        db.CasiAccidente_MedidaPrev.Remove(listamedidas[0]);
                        listamedidas.RemoveAt(0);
                    }
                }

                var condiciones = db.CasiAccidente_Condicion.Where(x => x.IdCasiAccidente == model.IdCasiAccidente);
                if (condiciones != null)
                {
                    var listacondiciones = condiciones.ToList();

                    while (listacondiciones.Count > 0)
                    {
                        db.CasiAccidente_Condicion.Remove(listacondiciones[0]);
                        listacondiciones.RemoveAt(0);
                    }
                }

                db.SaveChanges();

                casiAccidente = db.CasiAccidente.FirstOrDefault(x => x.IdCasiAccidente == model.IdCasiAccidente);

                db.CasiAccidente.Remove(casiAccidente);
                db.SaveChanges();

                return RedirectToAction("Inicio");
            }
            catch (Exception e)
            {
                return MostrarError(e.Message, "Ocurrio un error eliminar la cancha.");
            }
        }
        private CasiAccidenteModel ObtenerCasiAccidente(int IdCasiAccidente, bool CargarDetalles)
        {
            var l = db.CasiAccidente.FirstOrDefault(x => x.IdCasiAccidente == IdCasiAccidente);

            var item = new CasiAccidenteModel();

            item.IdCasiAccidente = l.IdCasiAccidente;
            item.Analisis = l.Analisis;
            item.Condicion = l.Condicion;
            item.PersonalApoyo = l.PersonalApoyo;
            item.Peligro = l.Peligro;
            item.OtraCondicion = l.OtraCondicion;

            item.Fecha = l.Fecha._ToDateTime().ToShortDateString();
            item.FechaCierre = l.FechaCierre._ToDateTime().ToShortDateString();
            // item.Hora = l.Hora._ToDateTime().ToShortTimeString();

            if (l.Direccion != null)
            {
                item.IdDireccion = l.IdDireccion._ToInt();
                item.Direccion = l.Direccion.Descripcion;
            }

            if (l.Responsable_EHS != null)
            {
                item.IdResponsable_EHS = l.IdResponsable_EHS._ToInt();
                item.Responsable_EHS = l.Responsable_EHS.Nombre + " " + l.Responsable_EHS.Apellido;
            }

            if (CargarDetalles)
            {
                if (l.CasiAccidente_MedidaPrev != null)
                {
                    foreach (var m in l.CasiAccidente_MedidaPrev)
                    {
                        var mp = new MedidaPreventivaModel();
                        mp.IdCasiAccidente = item.IdCasiAccidente._ToInt();
                        mp.Eliminada = false;
                        mp.Agregada = false;

                        mp.IdMedidaPreventiva = m.IdMedidaPreventiva;
                        mp.MedidaPreventiva = m.MedidaPreventiva.Descripcion;

                        mp.IdResponsable = m.IdResponsable;
                        mp.Responsable = m.Responsable.Nombre + " " + m.Responsable.Apellido;

                        item.MedidasPreventivas.Add(mp);
                    }
                }

                if (l.CasiAccidente_Condicion != null)
                {
                    foreach (var c in l.CasiAccidente_Condicion)
                    {
                        var cc = new CondicionModel();
                        cc.IdCasiAccidente = item.IdCasiAccidente;
                        cc.Eliminada = false;
                        cc.Agregada = false;

                        cc.IdCondicion = c.IdCondicion;
                        cc.Condicion = c.Condicion.Descripcion;

                        item.Condiciones.Add(cc);
                    }
                }
            }

            return item;
        }
        public CustomJson Guardar(CasiAccidenteModel model)
        {
            try
            {
                if (model._IsNullOrEmpty())
                {
                    return Resultado_Error("El registro es incorrecto.");
                }

                //Crear nuevo
                if (model.IdCasiAccidente <= 0)
                {
                    var ca = new CasiAccidente();
                    ca.Analisis = model.Analisis;
                    ca.Fecha = DateTime.Now;
                    ca.FechaCierre = DateTime.Now;
                    ca.IdDireccion = model.IdDireccion;
                    ca.IdResponsable_EHS = model.IdResponsable_EHS;
                    ca.OtraCondicion = model.OtraCondicion;
                    ca.Peligro = model.Peligro;
                    ca.PersonalApoyo = model.PersonalApoyo;

                    if (model.Condiciones._IsValid())
                    {
                        foreach (var cond in model.Condiciones)
                        {
                            var c = new CasiAccidente_Condicion();
                            c.IdCondicion = cond.IdCondicion;
                            ca.CasiAccidente_Condicion.Add(c);
                        }
                    }

                    if (model.MedidasPreventivas._IsValid())
                    {
                        foreach (var med in model.MedidasPreventivas)
                        {
                            var medPrev = new CasiAccidente_MedidaPrev();
                            medPrev.IdMedidaPreventiva = med.IdMedidaPreventiva;
                            medPrev.IdResponsable = med.IdResponsable;

                            ca.CasiAccidente_MedidaPrev.Add(medPrev);
                        }
                    }

                    db.CasiAccidente.Add(ca);
                    db.SaveChanges();

                    model.IdCasiAccidente = ca.IdCasiAccidente;
                    return Resultado_Correcto(model, "El registro ha sido creado el " + DateTime.Now.ToShortDateString() + DateTime.Now.ToShortTimeString());

                }
                //Editar actual
                else
                {
                    var ca = db.CasiAccidente.FirstOrDefault(x => x.IdCasiAccidente == model.IdCasiAccidente);
                    if (ca._IsNullOrEmpty())
                        return Resultado_Error("No se pudo cargar la informacion del casi accidente.");

                    ca.Analisis = model.Analisis;
                    ca.Fecha = DateTime.Now;
                    ca.FechaCierre = DateTime.Now;
                    ca.IdDireccion = model.IdDireccion;
                    ca.IdResponsable_EHS = model.IdResponsable_EHS;
                    ca.OtraCondicion = model.OtraCondicion;
                    ca.Peligro = model.Peligro;
                    ca.PersonalApoyo = model.PersonalApoyo;

                    if (model.Condiciones._IsValid())
                    {
                        foreach (var cond in model.Condiciones)
                        {
                            var condExistente = ca.CasiAccidente_Condicion.FirstOrDefault(x => x.IdCondicion == cond.IdCondicion);

                            if (cond.Agregada && condExistente._IsNullOrEmpty()) //Se agrego y no existe en la BDD
                            {
                                var c = new CasiAccidente_Condicion();
                                c.IdCondicion = cond.IdCondicion;
                                ca.CasiAccidente_Condicion.Add(c);
                            }

                            if (cond.Eliminada && cond._IsValid()) //Fue eliminada y aun esta en la BDD
                            {
                                ca.CasiAccidente_Condicion.Remove(condExistente);
                            }
                        }
                    }

                    if (model.MedidasPreventivas._IsValid())
                    {
                        foreach (var med in model.MedidasPreventivas)
                        {
                            var medExistente = ca.CasiAccidente_MedidaPrev.FirstOrDefault(x => x.IdMedidaPreventiva == med.IdMedidaPreventiva &&
                                                                                          x.IdResponsable == med.IdResponsable);

                            if (med.Agregada && medExistente._IsNullOrEmpty()) //Se agrego y no existe en la BDD esa medida para ese responsable
                            {
                                var medPrev = new CasiAccidente_MedidaPrev();
                                medPrev.IdMedidaPreventiva = med.IdMedidaPreventiva;
                                medPrev.IdResponsable = med.IdResponsable;
                                ca.CasiAccidente_MedidaPrev.Add(medPrev);
                            }

                            if (med.Eliminada && med._IsValid()) //Fue eliminada y aun esta en la BDD
                            {
                                ca.CasiAccidente_MedidaPrev.Remove(medExistente);
                            }
                        }
                    }

                    db.Entry(ca).State = EntityState.Modified;
                    db.SaveChanges();

                    return Resultado_Correcto(model, "El registro ha sido actualizado el " + DateTime.Now.ToShortDateString() + DateTime.Now.ToShortTimeString());
                }

            }
            catch (Exception e)
            {
                return Resultado_Exception(e);
            }
        }
        public CustomJson GetItem(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                var nuevo = new CasiAccidenteModel();
                nuevo.IdCasiAccidente = -1;

                //return Resultado_Correcto(nuevo, "Completar informacion para un nuevo registro.");
                return Resultado_Correcto(nuevo, "");
            }

            var item = ObtenerCasiAccidente(id._ToInt(), true);

            return Resultado_Correcto(item);
        }