protected void btnGuardar_Click(object sender, EventArgs e)
        {
            lblResultado.Text = string.Empty;
            //lblResultado.ForeColor = System.Drawing.Color.Red;
            lblResultado.Attributes["style"] = "color: #F00;";
            pnlResultado.Attributes["style"] = "background: rgba(252, 55, 55, 0.2);";
            Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
            if (ddlEstatusServidor.SelectedValue != "0" && ddlSO.SelectedValue != "0")
            {
                resultado.resultado = true;
                List<Entidades.ConfRed> consultaRed = new List<Entidades.ConfRed>();
                consultaRed = Negocio.Inventarios.ConfRed.Obtener(new Entidades.ConfRed() { DirIP = txtDirIP.Text.Trim() });
                if (consultaRed.Count > 0)
                {
                    Entidades.Logica.Error error = new Entidades.Logica.Error();
                    resultado.resultado = false;
                    error = new Entidades.Logica.Error();
                    error.idError = 4;
                    error.descripcionCorta = "Dirección de IP duplicada.";
                    resultado.errores.Add(error);
                }
                resultado.errores.ForEach(delegate (Entidades.Logica.Error error)
                {
                    lblResultado.Text += error.descripcionCorta + "<br>";
                });
                Entidades.Servidor servidor = new Entidades.Servidor();
                if (resultado.resultado == true)
                {
                    servidor.AliasServidor = txtAliasServidor.Text.Trim();
                    servidor.DescripcionUso = txtDescripcionUso.Text.Trim();
                    servidor.Modelo = null;
                    servidor.Especificacion = null;
                    servidor.TipoServidor = null;
                    servidor.Estatus.IdEstatus = Convert.ToInt32(ddlEstatusServidor.SelectedValue);
                    resultado = Negocio.Inventarios.Servidor.Nuevo(servidor);
                    resultado.errores.ForEach(delegate (Entidades.Logica.Error error)
                    {
                        lblResultado.Text += error.descripcionCorta + "<br>";
                    });
                }
                if(resultado.resultado == true)
                {
                    List<Entidades.Servidor> consultaServidor = new List<Entidades.Servidor>();
                    consultaServidor = Negocio.Inventarios.Servidor.Obtener(servidor);
                    if (consultaServidor.Count > 0)
                    {
                        int idSer = consultaServidor.First().IdServidor;

                        Entidades.SOxServidor so = new Entidades.SOxServidor();
                        so.Servidor.IdServidor = idSer;
                        so.SO.IdSO = Convert.ToInt32(ddlSO.SelectedValue);
                        so.Estatus = null;
                        resultado = Negocio.Inventarios.SOxServidor.Nuevo(so);
                        resultado.errores.ForEach(delegate (Entidades.Logica.Error error)
                        {
                            lblResultado.Text += error.descripcionCorta + "<br>";
                        });

                        Entidades.ConfRed red = new Entidades.ConfRed();
                        red.Servidor.IdServidor = idSer;
                        red.InterfazRed = txtInterfazRed.Text.Trim();
                        //red.DirMac = txtDirMAC.Text.Trim();
                        red.DirIP = txtDirIP.Text.Trim();
                        red.MascaraSubRed = txtMascaraSubRed.Text.Trim();
                        if(!string.IsNullOrWhiteSpace(txtGateway.Text.Trim()))
                            red.Gateway = txtGateway.Text.Trim();
                        if (!string.IsNullOrWhiteSpace(txtDNS.Text.Trim()))
                            red.DNS = txtDNS.Text.Trim();
                        //if (!string.IsNullOrWhiteSpace(txtVlan.Text.Trim()))
                        //    red.VLAN = txtVlan.Text.Trim();
                        //red.Estatus.IdEstatus = Convert.ToInt32(ddlEstatusRed.SelectedValue);
                        red.Estatus = null;
                        resultado = Negocio.Inventarios.ConfRed.Nuevo(red);
                        resultado.errores.ForEach(delegate (Entidades.Logica.Error error)
                        {
                            lblResultado.Text += error.descripcionCorta + "<br>";
                        });

                        Entidades.BitacoraMantenimiento bitacora = new Entidades.BitacoraMantenimiento();
                        bitacora.FechaCaptura = DateTime.Now;
                        bitacora.FechaMantenimiento = DateTime.Now;
                        bitacora.DescripcionMantenimiento = "Servidor registrado en el sistema.";
                        bitacora.Observaciones = "Sin observaciones.";
                        resultado = Negocio.Bitacoras.BitacoraMantenimiento.Nuevo(bitacora);
                        resultado.errores.ForEach(delegate (Entidades.Logica.Error error)
                        {
                            lblResultado.Text += error.descripcionCorta + "<br>";
                        });

                        if (resultado.resultado == true)
                        {
                            List<Entidades.BitacoraMantenimiento> conBitacor = new List<Entidades.BitacoraMantenimiento>();
                            conBitacor = Negocio.Bitacoras.BitacoraMantenimiento.Obtener(bitacora);
                            if (conBitacor.Count > 0)
                            {
                                int idBit = conBitacor.First().IdBitacora;
                                Entidades.PersonaXservidor asoc = new Entidades.PersonaXservidor();
                                asoc.Servidor.IdServidor = idSer;
                                asoc.Bitacora.IdBitacora = idBit;
                                asoc.Personas.IdPersona = ((Entidades.Usuarios)Session["usuario"]).IdPersona.IdPersona;
                                resultado = Negocio.Inventarios.PersonaXservidor.Nuevo(asoc);
                                resultado.errores.ForEach(delegate (Entidades.Logica.Error error)
                                {
                                    lblResultado.Text += error.descripcionCorta + "<br>";
                                });

                                if(resultado.resultado ==  true)
                                {
                                    pnlNuevoServidor.Visible = false;
                                    pnlServidores.Visible = true;
                                    llenarRprServidores();
                                }
                            }
                        }
                    }
                }
                if(resultado.resultado == true)
                {
                    //lblResultado.ForeColor = System.Drawing.Color.Green;
                    lblResultado.Attributes["style"] = "color: #008000;";
                    pnlResultado.Attributes["style"] = "background: rgba(147, 252, 55, 0.22);";
                }
            }
            else
            {
                lblResultado.Text = "Falta seleecionar algun item, revise y vuelva a intentar.";
            }
            pnlResultado.Visible = true;
        }
        protected void btnActualizar_Click(object sender, EventArgs e)
        {
            lblResultado.Text = string.Empty;
            lblResultado.ForeColor = System.Drawing.Color.Red;
            permisos = Negocio.Seguridad.Seguridad.verificarPermisos();
            Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
            if (permisos.U == true)
            {
                if (ddlModelo.SelectedValue != "0" && ddlTipoServidor.SelectedValue != "0" && ddlEstatus.SelectedValue != "0" && ddlProcesador.SelectedValue != "0" && ddlCapacidadRam.SelectedValue != "0" && ddlArregloDiscos.SelectedValue != "0")
                {
                    resultado.resultado = true;
                    if (ddlTipoServidor.SelectedValue == "3")
                    {
                        if (ddlVirtualizador.SelectedValue == "0")
                            resultado.resultado = false;
                    }

                    if (resultado.resultado == true)
                    {
                        //TODO
                        //Empieza la recolección de datos para actualizar el servidor
                        ObtenerDatos();

                        Entidades.EspServidor especificacion = new Entidades.EspServidor();
                        especificacion.IdServidor = _IdServidor;

                        List<Entidades.EspServidor> esp = new List<Entidades.EspServidor>();
                        esp = Negocio.Inventarios.EspServidor.Obtener(especificacion);

                        especificacion.Procesador.IdProcesador = Convert.ToInt32(ddlProcesador.SelectedValue);
                        especificacion.NumProcesadores = Convert.ToInt32(txtNumProcesadores.Text.Trim());
                        especificacion.CapacidadRAM = txtCapacidadRam.Text.Trim() + " " + ddlCapacidadRam.SelectedValue.Trim();
                        especificacion.TipoArregloDisco.IdTipoArreglo = Convert.ToInt32(ddlArregloDiscos.SelectedValue);
                        if (!string.IsNullOrWhiteSpace(txtNumSerie.Text.Trim()))
                        {
                            especificacion.NumSerie = txtNumSerie.Text.Trim();
                        }

                        if (esp.Count > 0)
                        {
                            especificacion.IdEspecificacion = esp.First().IdEspecificacion;
                            resultado = Negocio.Inventarios.EspServidor.Actualizar(especificacion);
                        }
                        else
                        {
                            resultado = Negocio.Inventarios.EspServidor.Nuevo(especificacion);
                        }

                        if (resultado.resultado == true)
                        {
                            List<Entidades.EspServidor> conEsp = new List<Entidades.EspServidor>();
                            conEsp = Negocio.Inventarios.EspServidor.Obtener(especificacion);
                            if (conEsp.Count > 0)
                            {
                                Entidades.Servidor servidor = new Entidades.Servidor();
                                servidor.IdServidor = _IdServidor;
                                servidor.AliasServidor = txtAliasServidor.Text.Trim();
                                servidor.Modelo.IdModelo = Convert.ToInt32(ddlModelo.SelectedValue);
                                servidor.Especificacion.IdEspecificacion = conEsp.First().IdEspecificacion;
                                servidor.TipoServidor.IdTipoServidor = Convert.ToInt32(ddlTipoServidor.SelectedValue);
                                servidor.IdVirtualizador = 0;
                                if (ddlVirtualizador.SelectedValue != "0")
                                    servidor.IdVirtualizador = Convert.ToInt32(ddlVirtualizador.SelectedValue);
                                servidor.DescripcionUso = txtDescripcion.Text.Trim();
                                servidor.Estatus.IdEstatus = Convert.ToInt32(ddlEstatus.SelectedValue);

                                Entidades.PersonaXservidor persona = new Entidades.PersonaXservidor();
                                persona.Servidor.IdServidor = _IdServidor;
                                persona.Personas.IdPersona = Convert.ToInt32(ddlPersona.SelectedValue);
                                persona.Bitacora = null;

                                List<Entidades.PersonaXservidor> pso = new List<Entidades.PersonaXservidor>();
                                pso = Negocio.Inventarios.PersonaXservidor.Obtener(persona);

                                var enc = from l in pso
                                          where l.Bitacora == null
                                          select l;
                                pso = enc.ToList();
                                if (pso.Count > 0)
                                {
                                    persona.IdPersonaServidor = pso.First().IdPersonaServidor;
                                    resultado = Negocio.Inventarios.PersonaXservidor.Actualizar(persona);
                                }
                                else
                                {
                                    resultado = Negocio.Inventarios.PersonaXservidor.Nuevo(persona);
                                }

                                resultado = Negocio.Inventarios.Servidor.Actualizar(servidor);
                            }
                        }
                    }
                    else
                    {
                        lblResultado.Text = "Debe seleccionar un virtualzador";
                    }

                    resultado.errores.ForEach(delegate (Entidades.Logica.Error error)
                    {
                        lblResultado.ForeColor = System.Drawing.Color.Red;
                        lblResultado.Text += error.descripcionCorta + "<br/>";
                    });

                    if (resultado.resultado == true)
                    {
                        lblResultado.ForeColor = System.Drawing.Color.Green;
                        pnlForm.Visible = false;
                        pnlCaracteristicas.Visible = true;
                        ObtenerDatos();
                        datosPrincipales(1);
                    }

                }
                else
                {
                    lblResultado.Text = "Revise el formulario, hay campos que no han sido seleccionados.";
                }
            }
            else
            {
                lblResultado.Text = "No tienes privilegios para actualizar la información.";
            }
        }
        protected void rptServidores_ItemDataBound(object sender, RepeaterItemEventArgs e)
        {
            HiddenField IdServidor = (HiddenField)e.Item.FindControl("hdfIdServidor");
            //HiddenField IdTipoServidor = (HiddenField)e.Item.FindControl("hdfIdTipoServidor");
            Label lblIp = (Label)e.Item.FindControl("lblIp");
            Label lblSO = (Label)e.Item.FindControl("lblSO");
            Label lblEncargado = (Label)e.Item.FindControl("lblEncargado");
            Label lblExtension = (Label)e.Item.FindControl("lblExtension");

            //Label lblTipo = (Label)e.Item.FindControl("lblTipo");

            int _IdServidor = Convert.ToInt32(IdServidor.Value);
            var _servidores = from l in _Servidores
                              where l.IdVirtualizador == _IdServidor
                              select l;

            List <Entidades.ConfRed> conRed = new List<Entidades.ConfRed>();
            conRed = Negocio.Inventarios.ConfRed.Obtener(
                new Entidades.ConfRed()
                {    Estatus = null,
                     Servidor= new Entidades.Servidor() { IdServidor = Convert.ToInt32(IdServidor.Value) }
                });
            if(conRed.Count > 0)
            {
                lblIp.Text = conRed.First().DirIP.Trim();
            }
            List<Entidades.SOxServidor> so = new List<Entidades.SOxServidor>();
            so = Negocio.Inventarios.SOxServidor.Obtener(new Entidades.SOxServidor()
            {
                 Estatus = null,
                 SO = null,
                 Servidor = new Entidades.Servidor() { IdServidor = Convert.ToInt32(IdServidor.Value) }
            });
            if(so.Count > 0)
            {
                lblSO.Text = so.First().SO.NombreSO.Trim();
            }

            Entidades.PersonaXservidor persona = new Entidades.PersonaXservidor();
            persona.Servidor.IdServidor = _IdServidor;
            persona.Personas = null;
            persona.Bitacora = null;
            List<Entidades.PersonaXservidor> pso = new List<Entidades.PersonaXservidor>();
            pso = Negocio.Inventarios.PersonaXservidor.Obtener(persona);
            var enc = from l in pso
                      where l.Bitacora == null
                      select l;
            pso = enc.ToList();
            if (pso.Count > 0)
            {
                lblEncargado.Text = pso.First().Personas.Nombre.Trim();
                lblExtension.Text = pso.First().Personas.Extension.Trim();
            }

            GridView gdvServidoresHijos = (GridView)e.Item.FindControl("gdvServidoresHijos");
            //gdvServidoresHijos.DataSource = Negocio.Inventarios.Servidor.Obtener(new Entidades.Servidor() { IdVirtualizador = _IdServidor });
            gdvServidoresHijos.DataSource = _servidores;
            gdvServidoresHijos.DataBind();
        }
        private void datosPrincipales(int opcion)
        {
            List<Entidades.Servidor> servidores = new List<Entidades.Servidor>();
            servidores = Negocio.Inventarios.Servidor.Obtener(new Entidades.Servidor() { IdServidor = _IdServidor, IdVirtualizador = -1 });
            if (opcion == 1)
            {
                lblVirtualizador.Visible =
                hlkVirtualizador.Visible = false;

                int InVirtualizador = 0;
                if (servidores.Count > 0)
                {
                    //lblAliasServidor.Text = servidores.First().AliasServidor;
                    lblDescripcionUso.Text = servidores.First().DescripcionUso;
                    if (servidores.First().Estatus != null)
                    {
                        lblEstatusServidor.Text = servidores.First().Estatus._Estatus;
                    }
                    if (servidores.First().TipoServidor != null)
                        lblTipoServidor.Text = servidores.First().TipoServidor.Tipo;
                    if (servidores.First().Modelo != null)
                    {
                        hdfIdModelo.Value = servidores.First().Modelo.IdModelo.ToString();
                        lblModelo.Text = servidores.First().Modelo.NombreModelo;
                    }
                    if (servidores.First().Especificacion != null)
                    {
                        lblNumProcesadores.Text = servidores.First().Especificacion.NumProcesadores.ToString();
                        lblCapacidadRam.Text = servidores.First().Especificacion.CapacidadRAM;
                        lblProcesador.Text = servidores.First().Especificacion.Procesador.Nombre + "<br>";
                        lblProcesador.Text += servidores.First().Especificacion.Procesador.NumCores.ToString() + " Core(s) <br>";
                        lblProcesador.Text += "Velocidad de " + servidores.First().Especificacion.Procesador.Velocidad + "<br>";
                        lblProcesador.Text += "Cache " + servidores.First().Especificacion.Procesador.Cache + "<br>";
                        lblProcesador.Text += "Tamaño de instrucción " + servidores.First().Especificacion.Procesador.TamanoPalabra + "<br>";
                    }
                    if (servidores.First().Especificacion != null)
                    {
                        if (servidores.First().Especificacion.TipoArregloDisco != null)
                            lblArregloDiscos.Text = servidores.First().Especificacion.TipoArregloDisco.Tipo;
                    }
                    InVirtualizador = servidores.First().IdVirtualizador ;
                }

                if (InVirtualizador != 0)
                {
                    servidores = new List<Entidades.Servidor>();
                    servidores = Negocio.Inventarios.Servidor.Obtener(new Entidades.Servidor() { IdServidor = InVirtualizador, IdVirtualizador = -1 });
                    if (servidores.Count > 0)
                    {
                        lblVirtualizador.Attributes["style"] = "font-weight: 600;font-size:14px;font-style:normal;text-shadow:none;margin:0;padding:0;";
                        lblVirtualizador.Visible =
                        hlkVirtualizador.Visible = true;
                        hlkVirtualizador.Text = servidores.First().AliasServidor;
                        hlkVirtualizador.NavigateUrl = "../Inventarios/DetalleServidor.aspx?IdServidor=" + servidores.First().IdServidor.ToString();
                    }
                }
                lblSoporte.ForeColor = System.Drawing.Color.Red;
                List<Entidades.Soporte> soporte = new List<Entidades.Soporte>();
                int IdModelo = !string.IsNullOrEmpty(hdfIdModelo.Value) ? Convert.ToInt32(hdfIdModelo.Value) : 0;
                if (IdModelo > 0)
                {
                    soporte = Negocio.Inventarios.Soporte.Obtener(new Entidades.Soporte() { Modelo = new Entidades.Modelo() { IdModelo = IdModelo } });
                    if (soporte.Count > 0)
                    {
                        if (soporte.First().FechaInicio < DateTime.Now && DateTime.Now < soporte.First().FechaFin)
                        {
                            lblSoporte.ForeColor = System.Drawing.Color.Green;
                            lblSoporte.Text = " de ";
                            lblSoporte.Text += ((DateTime)soporte.First().FechaInicio).ToString("dd/MM/yyyy") + " a ";
                            lblSoporte.Text += ((DateTime)soporte.First().FechaFin).ToString("dd/MM/yyyy") + "<br>";
                            lblSoporte.Text += soporte.First().Empresa.Nombre + "<br>";
                            lblSoporte.Text += "Tel:" + soporte.First().Empresa.Telefono + "<br>";
                        }
                        else
                        {
                            lblSoporte.Text = "Sin soporte.";
                        }
                    }
                }
                else
                {
                    lblSoporte.Text = "Sin soporte.";
                }

                Entidades.PersonaXservidor persona = new Entidades.PersonaXservidor();
                persona.Servidor.IdServidor = _IdServidor;
                persona.Personas = null;
                persona.Bitacora = null;

                List<Entidades.PersonaXservidor> pso = new List<Entidades.PersonaXservidor>();
                pso = Negocio.Inventarios.PersonaXservidor.Obtener(persona);
                var enc = from l in pso
                          where l.Bitacora == null
                          select l;
                pso = enc.ToList();
                if (pso.Count > 0)
                {
                    lblPersonaEncargada.Text = pso.First().Personas.Nombre.Trim();
                }
            }
            else if (opcion == 2)
            {
                limpiar();
                if (servidores.Count > 0)
                {
                    txtAliasServidor.Text = servidores.First().AliasServidor;
                    txtDescripcion.Text = servidores.First().DescripcionUso;
                    if (servidores.First().IdVirtualizador != 0)
                    {
                        ddlVirtualizador.Enabled = true;
                        ddlVirtualizador.SelectedValue = servidores.First().IdVirtualizador.ToString();
                    }
                    if (servidores.First().TipoServidor != null)
                        ddlTipoServidor.SelectedValue = servidores.First().TipoServidor.IdTipoServidor.ToString();
                    if (servidores.First().Modelo != null)
                    {
                        hdfIdModelo.Value = servidores.First().IdModelo.ToString();
                        ddlMarca.SelectedValue = servidores.First().Modelo.IdMarca.ToString();
                        llenarDdlModelo();
                        ddlModelo.SelectedValue = servidores.First().Modelo.IdModelo.ToString();
                    }
                    if (servidores.First().Especificacion != null)
                    {
                        txtNumProcesadores.Text = servidores.First().Especificacion.NumProcesadores.ToString();
                        txtCapacidadRam.Text = servidores.First().Especificacion.CapacidadRAM.Split(' ').ElementAt(0);
                        ddlCapacidadRam.SelectedValue = servidores.First().Especificacion.CapacidadRAM.Split(' ').ElementAt(1);
                        ddlProcesador.SelectedValue = servidores.First().Especificacion.Procesador.IdProcesador.ToString();

                        lblCaracteristicasProc.Text = servidores.First().Especificacion.Procesador.NumCores.ToString();
                        lblCaracteristicasProc.Text += " " + servidores.First().Especificacion.Procesador.Velocidad.Trim();
                        lblCaracteristicasProc.Text += " " + servidores.First().Especificacion.Procesador.Cache.Trim();
                        lblCaracteristicasProc.Text += " " + servidores.First().Especificacion.Procesador.TamanoPalabra.Trim();

                        txtNumProcesadores.Text = servidores.First().Especificacion.NumProcesadores.ToString();

                    }
                    if (servidores.First().Especificacion != null)
                    {
                        if (servidores.First().Especificacion.TipoArregloDisco != null)
                            ddlArregloDiscos.SelectedValue = servidores.First().Especificacion.TipoArregloDisco.IdTipoArreglo.ToString();
                    }
                    ddlEstatus.SelectedValue = servidores.First().Estatus.IdEstatus.ToString();

                    Entidades.PersonaXservidor persona = new Entidades.PersonaXservidor();
                    persona.Servidor.IdServidor = _IdServidor;
                    persona.Personas = null;
                    persona.Bitacora = null;

                    List<Entidades.PersonaXservidor> pso = new List<Entidades.PersonaXservidor>();
                    pso = Negocio.Inventarios.PersonaXservidor.Obtener(persona);
                    pso = Negocio.Inventarios.PersonaXservidor.Obtener(persona);
                    var enc = from l in pso
                              where l.Bitacora == null
                              select l;
                    pso = enc.ToList();
                    if (pso.Count > 0)
                    {
                        ddlPersona.SelectedValue = pso.First().Personas.IdPersona.ToString();
                    }
                }
            }
        }