コード例 #1
0
        private void imprimirTitulo()
        {
            Entidades.Servidor nServidor = new Entidades.Servidor();

            List<Entidades.Servidor> s = new List<Entidades.Servidor>();
            s = Negocio.Inventarios.Servidor.Obtener(new Entidades.Servidor()
            {
                IdServidor = _IdServidor,
                Modelo = null,
                Especificacion = null,
                TipoServidor = null,
                Estatus = null,
                AliasServidor = null,
                IdVirtualizador = -1,
                DescripcionUso = null
            }
            );
            if(s.Count > 0)
            {
                nServidor = s.First();
                lblNombreServidor.Text = nServidor.AliasServidor;
                lblNombreServidor.Attributes["style"] = "text-transform: uppercase;";
            }
        }
コード例 #2
0
        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;
        }
コード例 #3
0
        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.";
            }
        }