Esempio n. 1
0
 private void NombresTextBox_KeyPress(object sender, KeyPressEventArgs e) // Del nombre a la cedula
 {
     if ((int)e.KeyChar == (int)Keys.Enter)
     {
         CedulaMaskedTextBox.Focus();
     }
 }
        private bool Validar()
        {
            bool paso = true;
            MyErrorProvider.Clear();

            if(NombresTextBox.Text == string.Empty)
            {
                MyErrorProvider.SetError(NombresTextBox, "El campo nombre no puede estar vacio");
                NombresTextBox.Focus();
                paso = false;
            }
            
            if (string.IsNullOrWhiteSpace(MatriculaTextBox.Text))
            {
                MyErrorProvider.SetError(MatriculaTextBox, "El campo matricula no pude estar vacio");
                MatriculaTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo Cedula no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }
            return paso;
        }
        private bool Validar()
        {
            bool paso = true;

            MyErrorProvider.Clear();

            if (string.IsNullOrWhiteSpace(NombreTextBox.Text))
            {
                MyErrorProvider.SetError(NombreTextBox, "El campo Nombre no puede estar vacio");
                NombreTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(ApellidoTextBox.Text))
            {
                MyErrorProvider.SetError(ApellidoTextBox, "El campo Apellido no puede estar vacio");
                ApellidoTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo Cedula no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(MatriculaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(MatriculaMaskedTextBox, "El campo Matricula no puede estar vacio");
                MatriculaMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(TelefonoMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(TelefonoMaskedTextBox, "El campo Telefono no puede estar vacio");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El campo Celular no puede estar vacio");
                CelularMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(SexoComboBox.Text))
            {
                MyErrorProvider.SetError(SexoComboBox, "El campo Sexo no puede estar vacio");
                SexoComboBox.Focus();
                paso = false;
            }


            return(paso);
        }
 private void NuevoButton_Click(object sender, EventArgs e)
 {
     IDNumericUpDown.Value     = 0;
     FechaDateTimePicker.Value = DateTime.Now;
     NombresTextBox.Clear();
     DireccionTextBox.Clear();
     CedulaMaskedTextBox.Clear();
     TelefonoMaskedTextBox.Clear();
 }
Esempio n. 5
0
        private bool Validar()
        {
            bool paso = true;

            if (string.IsNullOrWhiteSpace(NombresTextBox.Text))
            {
                MyErrorProvider.SetError(NombresTextBox, "El campo Nombres no puede estar vacio");
                NombresTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(ApellidosTextBox.Text))
            {
                MyErrorProvider.SetError(ApellidosTextBox, "El campo Apellidos no puede estar vacio");
                ApellidosTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(TelefonoMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(TelefonoMaskedTextBox, "El campo Telefono no puede estar vacio");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El campo Celular no puede estar vacio");
                CelularMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(EmailTextBox.Text))
            {
                MyErrorProvider.SetError(EmailTextBox, "El campo Email no puede estar vacio");
                EmailTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(DireccionTextBox.Text))
            {
                MyErrorProvider.SetError(DireccionTextBox, "El campo Direccion no puede estar vacio");
                DireccionTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo Cedula no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }


            return(paso);
        }
 private void NuevoButton_Click(object sender, EventArgs e)
 {
     ClienteIdNumericUpDown.Value = 0;
     NombresTextBox.Clear();
     SexoComboBox.Text.ToString();
     CedulaMaskedTextBox.Clear();
     FechaDateTimePicker.ResetText();
     DireccionTextBox.Clear();
     NumeroCelularMaskedTextBox.Clear();
 }
Esempio n. 7
0
 private void NuevoButton_Click(object sender, EventArgs e)
 {
     ClienteIdNumericUpDown.Value = 0;
     FechaDateTimePicker.ResetText();
     NombresTextBox.Clear();
     DireccionTextBox.Clear();
     CedulaMaskedTextBox.Clear();
     SexoComboBox.SelectedIndex = 0;
     TelefonoMaskedTextBox.Clear();
     BalanceNumericUpDown.Value = 0;
     MyErrorProvider.Clear();
 }
Esempio n. 8
0
 private void Limpiar()
 {
     IdnumericUpDown.Value = 0;
     NombrestextBox.Clear();
     DirecciontextBox.Clear();
     EmailtextBox.Clear();
     CedulaMaskedTextBox.Clear();
     CelularMaskedTextBox.Clear();
     TelefonoMaskedTextBox.Clear();
     DeudaTextBox.Text = "0";
     MyErrorProvider.Clear();
 }
Esempio n. 9
0
        private bool Validar()
        {
            bool paso = true;

            MyErrorProvider.Clear();

            if (string.IsNullOrWhiteSpace(NombresTextBox.Text))
            {
                MyErrorProvider.SetError(NombresTextBox, "El campo Nombre no puede estar vacio");
                NombresTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo Cedula no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(TelefonoMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(TelefonoMaskedTextBox, "El campo Telefono no puede estar vacio");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El campo Celular no puede estar vacio");
                CelularMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(DireccionTextBox.Text))
            {
                MyErrorProvider.SetError(DireccionTextBox, "El campo Direccion no puede estar vacio");
                DireccionTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(EmailTextBox.Text))
            {
                MyErrorProvider.SetError(DireccionTextBox, "El campo Email no puede estar vacio");
                EmailTextBox.Focus();
                paso = false;
            }
            if (FechaIngresoDateTimePicker.Value > DateTime.Now)
            {
                MyErrorProvider.SetError(FechaIngresoDateTimePicker, "No se puede registrar esta fecha.");
                paso = false;
            }

            return(paso);
        }
        public void Limpiar()
        {
            ClienteIdNumericUpDown.Value = 0;
            NombresTextBox.Clear();
            DireccionTextBox.Clear();
            SexoComboBox.Items.Clear();
            TelefonoMaskedTextBox.Clear();
            CedulaMaskedTextBox.Clear();
            FechaNacimientoDateTimePicker.ResetText();
            LlenarComboSexo();


            ErrorProvider.Clear();
        }
Esempio n. 11
0
        private bool Validar() //Funcion que valida todo el registro
        {
            bool paso = true;

            MyErrorProvider.Clear();
            if (NombresTextBox.Text == string.Empty)  //Validando que el nombre no este vacio
            {
                MyErrorProvider.SetError(NombresTextBox, "El campo \"Nombre\" no puede estar vacio");
                NombresTextBox.Focus();
                paso = false;
            }
            if (CedulaMaskedTextBox.Text.Trim().Length < 13 || CedulaMaskedTextBox.Text.Contains(" ")) //Validando que la cedula no este vacia o incompleta
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "Ingrese un numero de cedula valido");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }
            if (CelularMaskedTextBox.Text.Trim().Length < 12 || CelularMaskedTextBox.Text.Contains(" "))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "Ingrese un numero de celular valido"); // Validando que el numero de celular este vacio o incompleto
                CelularMaskedTextBox.Focus();
                paso = false;
            }
            if (TelefonoMaskedTextBox.Text.Contains("0") ||
                TelefonoMaskedTextBox.Text.Contains("1") ||
                TelefonoMaskedTextBox.Text.Contains("2") ||
                TelefonoMaskedTextBox.Text.Contains("3") ||
                TelefonoMaskedTextBox.Text.Contains("4") ||
                TelefonoMaskedTextBox.Text.Contains("5") ||
                TelefonoMaskedTextBox.Text.Contains("6") ||
                TelefonoMaskedTextBox.Text.Contains("7") ||
                TelefonoMaskedTextBox.Text.Contains("8") ||
                TelefonoMaskedTextBox.Text.Contains("9"))// Validando el numero de telefono, si tiene
            {
                if (TelefonoMaskedTextBox.Text.Trim().Length < 12)
                {
                    MyErrorProvider.SetError(TelefonoMaskedTextBox, "Ingrese un numero de celular valido"); //Validando que la fecha no se mayor a la fecha actual
                    TelefonoMaskedTextBox.Focus();
                    paso = false;
                }
            }
            if (FechaDeIngresoDateTimePicker.Value > DateTime.Now)  // Valinando que la fecha de ingreso no sea mayor a la actual
            {
                MyErrorProvider.SetError(FechaDeIngresoDateTimePicker, "La fecha de ingreso no puede ser mayor a la fecha actual");
                FechaDeIngresoDateTimePicker.Focus();
                paso = false;
            }
            return(paso);
        }
Esempio n. 12
0
        private bool Validar()
        {
            MyErrorProvider.Clear();
            bool paso = true;

            if (string.IsNullOrWhiteSpace(NombreTextBox.Text))
            {
                MyErrorProvider.SetError(NombreTextBox, "El campo nombre no ouede estar vacio");
                NombreTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo cedula no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(TipoComboBox.Text))
            {
                MyErrorProvider.SetError(TipoComboBox, "Debe de seleccionar un tipo de usuario");
                TipoComboBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El campo celular no puede estar vacio");
                CelularMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(UsuarioTextBox.Text))
            {
                MyErrorProvider.SetError(UsuarioTextBox, "El campo usuario no puede estar vacio");
                UsuarioTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(ContraseñaTextBox.Text))
            {
                MyErrorProvider.SetError(ContraseñaTextBox, "El campo contraseña no puuede estar vacio");
                ContraseñaTextBox.Focus();
                paso = false;
            }

            return(paso);
        }
        public bool validar()
        {
            bool paso = true;

            MyErrorProvider.Clear();

            if (string.IsNullOrWhiteSpace(NombreTextBox.Text))
            {
                MyErrorProvider.SetError(NombreTextBox, "El Campo nombre no puede estar vacio");
                NombreTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El Campo celular no puede estar vacio");
                CelularMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(TelefonoMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(TelefonoMaskedTextBox, "El Campo telefono no puede estar vacio");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El Campo cedula no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(SueldoTextBox.Text))
            {
                MyErrorProvider.SetError(SueldoTextBox, "El Campo sueldo no puede estar vacio");
                SueldoTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(DireccionTextBox.Text))
            {
                MyErrorProvider.SetError(DireccionTextBox, "El Campo direccion no puede estar vacio");
                DireccionTextBox.Focus();
                paso = false;
            }

            return(paso);
        }
 private void Limpiar()
 {
     IdTextBox.Clear();
     NombreTextBox.Clear();
     ApellidoTextBox.Clear();
     ApodoTextBox.Clear();
     DireccionTextBox.Clear();
     ReferenciaTextBox.Clear();
     CedulaMaskedTextBox.Clear();
     TelefonoMaskedTextBox.Clear();
     CelularMaskedTextBox.Clear();
     IdTextBox.Enabled            = false;
     MasculinoRadioButton.Checked = false;
     FemeninoRadioButton.Checked  = false;
     BuscarButton.Enabled         = false;
     GuardarButton.Enabled        = true;
     EliminarButton.Enabled       = false;
 }
Esempio n. 15
0
        private bool Validar()
        {
            bool paso = true;

            MyErrorProvider.Clear();
            if (string.IsNullOrWhiteSpace(NombresTextBox.Text))
            {
                MyErrorProvider.SetError(NombresTextBox, "El campo Nombres no puede estar vacio");
                NombresTextBox.Focus();
                paso = false;
            }

            /*if (MasculinoRadioButton.Checked == false   || FemeninoRadioButton.Checked == false)
             * {
             *  MyErrorProvider.SetError(FemeninoRadioButton, "Seleccione una Sexo");
             *  MasculinoRadioButton.Focus();
             *  FemeninoRadioButton.Focus();
             *  paso = false;
             * }*/
            if (string.IsNullOrWhiteSpace(GrupoSangineoComboBox.Text))
            {
                MyErrorProvider.SetError(GrupoSangineoComboBox, "El campo GrupoSangineo no puede estar vacio");
                GrupoSangineoComboBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo Cedula no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(TelefonoMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(TelefonoMaskedTextBox, "El campo Telefono no puede estar vacio");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El campo Celular no puede estar vacio");
                CelularMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(SeguroMedicoComboBox.Text))
            {
                MyErrorProvider.SetError(SeguroMedicoComboBox, "El campo Seguro Medico no puede estar vacio");
                SeguroMedicoComboBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(DireccionTextBox.Text))
            {
                MyErrorProvider.SetError(DireccionTextBox, "El campo Direccion no puede estar vacio");
                DireccionTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(EmailTextBox.Text))
            {
                MyErrorProvider.SetError(EmailTextBox, "El campo Seguro Medico no puede estar vacio");
                EmailTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(ObservacionTextBox.Text))
            {
                MyErrorProvider.SetError(ObservacionTextBox, "El campo Seguro Medico no puede estar vacio");
                ObservacionTextBox.Focus();
                paso = false;
            }


            return(paso);
        }
        private bool Validar()
        {
            bool paso = true;

            MyErrorProvider.Clear();
            if (string.IsNullOrWhiteSpace(NombresTextBox.Text))
            {
                MyErrorProvider.SetError(NombresTextBox, "El campo Nombres no puede estar vacio");
                NombresTextBox.Focus();
                paso = false;
            }


            if (string.IsNullOrWhiteSpace(GrupoSangineoComboBox.Text))
            {
                MyErrorProvider.SetError(GrupoSangineoComboBox, "El campo GrupoSangineo no puede estar vacio");
                GrupoSangineoComboBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo Cedula no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(TelefonoMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(TelefonoMaskedTextBox, "El campo Telefono no puede estar vacio");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El campo Celular no puede estar vacio");
                CelularMaskedTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(SeguroMedicoComboBox.Text))
            {
                MyErrorProvider.SetError(SeguroMedicoComboBox, "El campo Seguro Medico no puede estar vacio");
                SeguroMedicoComboBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(DireccionTextBox.Text))
            {
                MyErrorProvider.SetError(DireccionTextBox, "El campo Direccion no puede estar vacio");
                DireccionTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(EmailTextBox.Text))
            {
                MyErrorProvider.SetError(EmailTextBox, "El campo Seguro Medico no puede estar vacio");
                EmailTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(ObservacionTextBox.Text))
            {
                MyErrorProvider.SetError(ObservacionTextBox, "El campo Seguro Medico no puede estar vacio");
                ObservacionTextBox.Focus();
                paso = false;
            }
            if (FechaNacimientoDateTimePicker.Value > FechaIngresoDateTimePicker.Value)
            {
                MyErrorProvider.SetError(FechaNacimientoDateTimePicker, "No se puede registrar esta fecha.");
                FechaNacimientoDateTimePicker.Focus();
                paso = false;
            }
            if (FechaIngresoDateTimePicker.Value > DateTime.Now)
            {
                MyErrorProvider.SetError(FechaIngresoDateTimePicker, "No se puede registrar esta fecha.");
                FechaIngresoDateTimePicker.Focus();
                paso = false;
            }


            return(paso);
        }
        //Validacion de los campos de la clase
        public bool Validar()
        {
            bool paso = true;

            ErrorProvider.Clear();
            if (NombresTextBox.Text == string.Empty)
            {
                ErrorProvider.SetError(NombresTextBox, "El campo no puede estar vacio");
                NombresTextBox.Focus();
                paso = false;
            }
            if (DireccionTextBox.Text == string.Empty)
            {
                ErrorProvider.SetError(DireccionTextBox, "La direccion no puede esta vacia");
                DireccionTextBox.Focus();
                paso = false;
            }
            if (EmailTextBox.Text == string.Empty)
            {
                ErrorProvider.SetError(EmailTextBox, "El Email no puede esta vacio");
                EmailTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(NombresTextBox.Text))
            {
                ErrorProvider.SetError(NombresTextBox, "El campo no puede estar vacio");
                NombresTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(DireccionTextBox.Text))
            {
                ErrorProvider.SetError(DireccionTextBox, "La direccion no puede esta vacia");
                DireccionTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(EmailTextBox.Text))
            {
                ErrorProvider.SetError(EmailTextBox, "El Email no puede esta vacio");
                EmailTextBox.Focus();
                paso = false;
            }
            if (CedulaMaskedTextBox.MaskFull == false)
            {
                ErrorProvider.SetError(CedulaMaskedTextBox, "No puede haber espacios en blanco");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }
            if (TelefonoMaskedTextBox.MaskFull == false)
            {
                ErrorProvider.SetError(TelefonoMaskedTextBox, "No puede haber espacios en blanco");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }
            if (ValidarEmail(EmailTextBox.Text) == false)
            {
                ErrorProvider.SetError(EmailTextBox, "Correo invalido");
                EmailTextBox.Focus();
                paso = false;
            }
            if (MasculinoRadioButton.Checked == false && FemeninoRadioButton.Checked == false)
            {
                ErrorProvider.SetError(FemeninoRadioButton, "Es campo sexo no puede esta vacio");
                FemeninoRadioButton.Focus();
                paso = false;
            }

            return(paso);
        }
Esempio n. 18
0
        private bool Validar()
        {
            bool paso = true;

            MyErrorProvider.Clear();

            if (string.IsNullOrWhiteSpace(NombresTextBox.Text))
            {
                MyErrorProvider.SetError(NombresTextBox, "El campo Nombres no puede estar vacío.");
                NombresTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(ApellidosTextBox.Text))
            {
                MyErrorProvider.SetError(ApellidosTextBox, "El campo Apellidos no puede estar vacío.");
                ApellidosTextBox.Focus();
                paso = false;
            }
            if (string.IsNullOrWhiteSpace(MatriculaMaskedTextBox.Text.Replace("-", "")))
            {
                MyErrorProvider.SetError(MatriculaMaskedTextBox, "El campo Matrícula no puede estar vacío.");
                MatriculaMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text.Replace("-", "")))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo Cédula no puede estar vacío.");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(TelefonoMaskedTextBox.Text.Replace("-", "")))
            {
                MyErrorProvider.SetError(TelefonoMaskedTextBox, "El campo Teléfono no puede estar vacío.");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text.Replace("-", "")))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El campo Celular no puede estar vacío.");
                CelularMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(FechaNacimientoDateTimePicker.Text))
            {
                MyErrorProvider.SetError(FechaNacimientoDateTimePicker, "El campo Fecha no puede estar vacío.");
                FechaNacimientoDateTimePicker.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(SexoComboBox.Text))
            {
                MyErrorProvider.SetError(SexoComboBox, "El campo Sexo no puede estar vacío.");
                SexoComboBox.Focus();
                paso = false;
            }
            return(paso);
        }
Esempio n. 19
0
        private bool Validar()
        {
            MyErrorProvider.Clear();

            bool paso = true;

            if (string.IsNullOrWhiteSpace(NombreTextBox.Text))
            {
                MyErrorProvider.SetError(NombreTextBox, "El campo nombre no puede estar vacío");
                NombreTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(TelefonoMaskedTextBox.Text.Replace("-", string.Empty)) || string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text.Replace("-", string.Empty)))
            {
                MyErrorProvider.SetError(TelefonoMaskedTextBox, "Debe de suministrar un numero de telefono o celular");
                MyErrorProvider.SetError(CelularMaskedTextBox, "Debe de suministrar un numero de telefono o celular");
                TelefonoMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text.Replace("-", string.Empty)))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo cedula no puede estar vacío");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(GeneroComboBox.Text))
            {
                MyErrorProvider.SetError(GeneroComboBox, "Debe de seleccionar su genero");
                GeneroComboBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(EmailTextBox.Text))
            {
                MyErrorProvider.SetError(EmailTextBox, "El campo email no puede estar vacío");
                EmailTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(DireccionTextBox.Text))
            {
                MyErrorProvider.SetError(DireccionTextBox, "El campo direccion no puede estar vacío");
                DireccionTextBox.Focus();
                paso = false;
            }

            if (ImagenPictureBox.Image == ImagenOriginal)
            {
                MyErrorProvider.SetError(InsertarImagenButton, "Debe de suministrar una imagen de usuario");
                InsertarImagenButton.Focus();
                paso = false;
            }

            if (!EmailTextBox.Text.Contains("@"))
            {
                MyErrorProvider.SetError(EmailTextBox, "El email debe de tener arroba '@'. ");
                EmailTextBox.Focus();
                paso = false;
            }

            return(paso);
        }
Esempio n. 20
0
        private bool Validar()
        {
            MyErrorProvider.Clear();
            bool paso = true;

            if (string.IsNullOrWhiteSpace(NombreTextBox.Text))
            {
                MyErrorProvider.SetError(NombreTextBox, "El campo nombre no puede estar vacio");
                NombreTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CelularMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CelularMaskedTextBox, "El campo celular no puede estar vacio");
                CelularMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(CedulaMaskedTextBox.Text))
            {
                MyErrorProvider.SetError(CedulaMaskedTextBox, "El campo celular no puede estar vacio");
                CedulaMaskedTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(GeneroComboBox.Text))
            {
                MyErrorProvider.SetError(GeneroComboBox, "Debe seleccionar un genero");
                GeneroComboBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(TipoComboBox.Text))
            {
                MyErrorProvider.SetError(TipoComboBox, "Debe seleccionar un Ttipo de usuario");
                TipoComboBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(EmailTextBox.Text))
            {
                MyErrorProvider.SetError(EmailTextBox, "El campo email no puede estar vacio");
                EmailTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(UsuarioTextBox.Text))
            {
                MyErrorProvider.SetError(UsuarioTextBox, "El campo usuario no puede estar vacio");
                UsuarioTextBox.Focus();
                paso = false;
            }

            if (string.IsNullOrWhiteSpace(ContraseñaTextBox.Text))
            {
                MyErrorProvider.SetError(ContraseñaTextBox, "El campo contraseña no puede estar vacio");
                ContraseñaTextBox.Focus();
                paso = false;
            }

            if (!EmailTextBox.Text.EndsWith("@gmail.com") && !EmailTextBox.Text.EndsWith("@outlook.com"))
            {
                MyErrorProvider.SetError(EmailTextBox, "El email debe de ser de @gmail.com o @outlook.com \npara poder realizar futuras recuperaciones");
                EmailTextBox.Focus();
                paso = false;
            }

            if (ContraseñaTextBox.Text.Length < 4)
            {
                MyErrorProvider.SetError(ContraseñaTextBox, "La contraseña debe de tener 4 o mas caracteres");
                ContraseñaTextBox.Focus();
                paso = false;
            }

            return(paso);
        }