Esempio n. 1
0
        /// <summary>
        /// méthode de vérification de certains champ saisie
        /// </summary>
        /// <param name="sender">object appelant</param>
        private void IsVerifChampSaisie(object sender)
        {
            TextBox t = sender as TextBox;

            t.BorderBrush    = Brushes.Gray;
            t.SelectionBrush = Brushes.Gray;

            switch (t.Name)
            {
            case "TextBoxMatricule":
                if (!Salarie.IsMatriculeValide(t.Text.Trim()))
                {
                    ErreurSaisie(sender);
                }
                break;

            case "TextBoxNom":
            case "TextBoxPrenom":
                if (!Salarie.IsNomPrenomValide(t.Text.Trim()))
                {
                    ErreurSaisie(sender);
                }
                break;
            }
        }
Esempio n. 2
0
 private void tbMatricule_Validating(object sender, CancelEventArgs e)
 {
     if (Salarie.IsMatriculeValide(tbMatricule.Text))
     {
         epSalarie.SetError(tbMatricule, string.Empty);
     }
     else
     {
         epSalarie.SetError(tbMatricule, "Le matricule est incorrect");
     }
 }
Esempio n. 3
0
 void textBoxMatricule_Validating(object sender, CancelEventArgs e)
 {
     if (!(Salarie.IsMatriculeValide(textBoxMatricule.Text)))
     {
         erreurCb.SetError(textBoxMatricule, "Matricule non valide");
     }
     else
     {
         erreurCb.SetError(textBoxMatricule, "");
     }
 }
Esempio n. 4
0
        private static void Test()
        {
            Console.WriteLine("Test de la méthode vérification Matricule");
            Console.WriteLine
                ($"Test nom vide {Salarie.IsMatriculeValide("") == false})");
            Console.WriteLine
                ($"Test longueur > 7 {Salarie.IsMatriculeValide("12345678") == false})");
            Console.WriteLine
                ($"Test caractère spécial {Salarie.IsMatriculeValide("12&FT78") == false})");
            Console.WriteLine
                ($"Test non digit {Salarie.IsMatriculeValide("A2EFT78") == false})");
            Console.WriteLine
                ($"Test nom vide {Salarie.IsMatriculeValide("12EFT78") == true})");

            try
            {
                Salarie sal = new Salarie("Bost", "Vincent", "12aaa55");
                sal.DateNaissance = new DateTime(2000, 05, 29);
                sal.SalaireBrut   = 1980.25m;
                sal.TauxCS        = .30m;
                Salarie sal1 = new Salarie(sal);
                sal1.DateNaissance = new DateTime(2000, 05, 29);
                sal1.SalaireBrut   = 1980.25m;
                sal1.TauxCS        = .30m;
                Salarie sal2 = new Salarie("Bost", "Vincent", "12aaa55");
                sal2.DateNaissance = new DateTime(2000, 05, 29);
                sal2.SalaireBrut   = 1980.25m;
                sal2.TauxCS        = .30m;
                Salarie sal3 = new Salarie("Peyramard", "Florian", "25bbb55");
                Console.WriteLine(@"Le salarié {0} {1} a été créé et son salaire net est de {2:n} euros", sal.Prenom, sal.Nom, sal.SalaireNet);
                Console.WriteLine("Etape 1 Le nombre d'instances en mémoire de salariés est de {0}", Salarie.NombreInstances);
                Console.WriteLine("Appuyez sur la touche Entrée pour détruire la référence au salarié");
                // Console.ReadLine();
                bool verif    = sal.Equals(sal2);
                int  hashcode = sal3.GetHashCode();
                // Console.WriteLine($"equal,{hashcode}");
                // string str = sal.ToString();
                // Console.WriteLine(str);

                Commercial c1 = new Commercial("Dupond", "Michel", "56rrr99");
                Console.WriteLine(c1.ToString());
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
Esempio n. 5
0
        private bool IsValidChampsSalarie()
        {
            bool valid = true;

            ep_Salarie.SetError(txtB_Matricule, string.Empty);
            ep_Salarie.SetError(txtB_Nom, string.Empty);
            ep_Salarie.SetError(txtB_Prenom, string.Empty);
            ep_Salarie.SetError(mTxtB_DateDeNaissance, string.Empty);


            if (!Salarie.IsMatriculeValide(txtB_Matricule.Text))
            {
                valid = false;
                ep_Salarie.SetError(txtB_Matricule, "Le matricule n'est pas valide");
            }
            else if (!Salarie.IsNomPrenomValide(txtB_Nom.Text))
            {
                valid = false;
                ep_Salarie.SetError(txtB_Nom, "Le nom n'est pas valide");
            }
            else if (!Salarie.IsNomPrenomValide(txtB_Prenom.Text))
            {
                valid = false;
                ep_Salarie.SetError(txtB_Prenom, "Le prénom n'est pas valide");
            }

            else if (!Salarie.IsDateNaissanceValide(Convert.ToDateTime(mTxtB_DateDeNaissance.Text)))
            {
                valid = false;
                ep_Salarie.SetError(mTxtB_DateDeNaissance, "La date de naissance n'est pas valide");
            }


            else
            {
                ep_Salarie.SetError(txtB_Matricule, string.Empty);
                ep_Salarie.SetError(txtB_Nom, string.Empty);
                ep_Salarie.SetError(txtB_Prenom, string.Empty);
                ep_Salarie.SetError(mTxtB_DateDeNaissance, string.Empty);
            }



            return(valid);
        }
Esempio n. 6
0
        private bool IsValidChamps()
        {
            bool valid = true;

            if (!Salarie.IsMatriculeValide(txtMatricule.Text))
            {
                valid = false;
                epSalarie.SetError(txtMatricule, "L'identifiant n'est pas valide");
            }
            else
            {
                epSalarie.SetError(txtMatricule, string.Empty);
            }



            return(valid);
        }
Esempio n. 7
0
        public bool VerifValiditeSalarie()
        {
            Salarie salarie = new Salarie();

            if (!Salarie.IsNomPrenomValide(textBoxNom.Text))
            {
                return(false);
            }

            if (!Salarie.IsNomPrenomValide(textBoxPrenom.Text))
            {
                return(false);
            }
            bool ConvertionDate = DateTime.TryParse(textBoxDateDeNaissance.Text, out DateTime DateNaissanceConvertie);

            if (!ConvertionDate == true && Salarie.IsDateNaissanceValide(DateNaissanceConvertie))
            {
                return(false);
            }
            if (!Salarie.IsMatriculeValide(textBoxMatricule.Text))
            {
                return(false);
            }
            bool ConvertionSalaire = decimal.TryParse(textBoxSalaireBrut.Text, out decimal SalaireBrutConverti);

            if (!ConvertionSalaire == true)
            {
                return(false);
            }
            bool ConvertionTauxCS = decimal.TryParse(textBoxTauxCS.Text, out decimal TauxCSConverti);

            if (!(ConvertionTauxCS == true && Salarie.IsTauxCSValid(TauxCSConverti)))
            {
                return(false);
            }
            return(true);
        }
Esempio n. 8
0
        /// <summary>
        /// vérifie les champs et renvoie un bool
        /// </summary>
        /// <returns></returns>
        private bool IsVerifChamp()
        {
            if (!Salarie.IsMatriculeValide(TextBoxMatricule.Text.Trim()))
            {
                ErreurSaisie(TextBoxMatricule);
                return(false);
            }

            if (!Salarie.IsNomPrenomValide(TextBoxNom.Text.Trim()))
            {
                ErreurSaisie(TextBoxNom);
                return(false);
            }

            if (!Salarie.IsNomPrenomValide(TextBoxPrenom.Text.Trim()))
            {
                ErreurSaisie(TextBoxPrenom);
                return(false);
            }

            if (!Salarie.IsDateNaissanceValide(DatePickerDateDeNaissance.SelectedDate.Value))
            {
                ErreurSaisie(DatePickerDateDeNaissance);
                return(false);
            }
            if (string.IsNullOrEmpty(TextBoxSalaireBrut.Text.Trim()) | string.IsNullOrEmpty(TextBoxTauxCotisationSociale.Text.Trim()))
            {
                return(false);
            }
            if ((bool)CheckBoxCommercial.IsChecked & (string.IsNullOrEmpty(TextBoxCommission.Text.Trim()) | string.IsNullOrEmpty(TextBoxChiffreDAffaire.Text.Trim())))
            {
                return(false);
            }

            return(true);
        }
Esempio n. 9
0
        private bool IsValidChamps()
        {
            bool valid = true;

            if (!Salarie.IsMatriculeValide(tbID.Text))
            {
                valid = false;
                epSal.SetError(tbID, "L'identifiant n'est pas valide");
            }
            else
            {
                epSal.SetError(tbID, string.Empty);
            }
            if (!Salarie.IsNomPrenomValide(tbMDP.Text))
            {
                valid = false;
                epSal.SetError(tbMDP, "Le prénom n'est pas valide");
            }
            else
            {
                epSal.SetError(tbMDP, string.Empty);
            }

            if (!Salarie.IsNomPrenomValide(tbNom.Text))
            {
                valid = false;
                epSal.SetError(tbNom, "Le nom n'est pas valide");
            }

            else
            {
                epSal.SetError(tbNom, string.Empty);
            }

            return(valid);
        }
Esempio n. 10
0
        private bool IsValidChamps()
        {
            bool valid = true;


            if (!Salarie.IsMatriculeValide(tbMatricule.Text))
            {
                epSalarie.SetError(tbMatricule, "Le matricule est incorrect");
                return(false);
            }
            else
            {
                epSalarie.SetError(tbMatricule, "");
            }
            if (!Salarie.IsNomPrenomValide(tbNom.Text))
            {
                epSalarie.SetError(tbNom, "Le nom est incorrect");
                return(false);
            }
            else
            {
                epSalarie.SetError(tbNom, "");
            }
            if (!Salarie.IsNomPrenomValide(tbNom.Text))
            {
                epSalarie.SetError(tbPrenom, "Le prénom est incorrect");
                return(false);
            }
            else
            {
                epSalarie.SetError(tbPrenom, "");
            }
            if (!Salarie.IsDateNaissanceValide(DateTime.Parse(dtpDateNaissance.Text)))
            {
                epSalarie.SetError(dtpDateNaissance, "La date de naissance est incorrecte");
                return(false);
            }
            else
            {
                epSalarie.SetError(dtpDateNaissance, "");
            }
            decimal salaireConverti;
            bool    conv = decimal.TryParse(tbSalaireBrut.Text, out salaireConverti);

            if (!conv)
            {
                epSalarie.SetError(tbSalaireBrut, "La valeur doit être un décimal");
                return(false);
            }
            if (!Salarie.IsSalaireValide(salaireConverti))
            {
                epSalarie.SetError(tbSalaireBrut, "Le salaire brut est incorrect");
                return(false);
            }
            else
            {
                epSalarie.SetError(tbSalaireBrut, "");
            }
            decimal tauxConverti;
            bool    convers = decimal.TryParse(tbTaux.Text, out tauxConverti);

            if (!convers)
            {
                epSalarie.SetError(tbSalaireBrut, "La valeur doit être un décimal");
                return(false);
            }
            if (!Salarie.IsTauxCSValide(tauxConverti))
            {
                epSalarie.SetError(tbTaux, "Le tauxCS est incorrect");
                return(false);
            }
            else
            {
                epSalarie.SetError(tbTaux, "");
            }

            return(valid);
        }
Esempio n. 11
0
        //private void SupprimerSalarie()
        //{

        //    MessageBox.Show("etes-vous sur");
        //  //cours++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        //   DialogResult suppressionResult = MessageBox.ShowDialog();

        //    switch (suppressionResult)
        //    {
        //        case DialogResult.None:
        //            SuppressionModal.ShowDialog();
        //            break;

        //        case DialogResult.OK:
        //            salaries.Remove(salarie);
        //            salaries.Save(MonApplication.DispositifSauvegarde, Settings.Default.AppData);
        //            break;

        //        case DialogResult.Cancel:
        //            SuppressionModal.Close();
        //            Close();
        //            break;

        //    }


        //}
        #endregion

        #region Validité


        private bool IsValidChamps()
        {
            bool valid = true;

            if (!Salarie.IsMatriculeValide(textBoxMatricule.Text))
            {
                valid = false;
                epSalarie.SetError(textBoxMatricule, "Le matricule n'est pas valide");
            }
            else
            {
                epSalarie.SetError(textBoxMatricule, string.Empty);
            }
            //------------------------------------------------------------------------------------
            if (!Salarie.IsNomPrenomValide(textBoxNom.Text))
            {
                valid = false;
                epSalarie.SetError(textBoxNom, "Le nom n'est pas valide");
            }
            else
            {
                epSalarie.SetError(textBoxNom, string.Empty);
            }
            //------------------------------------------------------------------------------------

            if (!Salarie.IsNomPrenomValide(textBoxPrenom.Text))
            {
                valid = false;
                epSalarie.SetError(textBoxPrenom, "Le prenom n'est pas valide");
            }
            else
            {
                epSalarie.SetError(textBoxPrenom, string.Empty);
            }
            //-----------------------------------------------------------------------------------
            DateTime naissanceConvertie;

            if (!DateTime.TryParse(textBoxDatedeNaissance.Text, out naissanceConvertie))
            {
                valid = false;
                epSalarie.SetError(textBoxDatedeNaissance, "La date de naissance n'est pas valide");
            }
            else
            {
                epSalarie.SetError(textBoxDatedeNaissance, string.Empty);
            }
            //---- ----------------------------------------------------- ----------------------
            decimal salaireConverti;

            if ((!decimal.TryParse(textBoxSalaireBrut.Text, out salaireConverti)) || decimal.Parse(textBoxSalaireBrut.Text) < 0)

            {
                valid = false;
                epSalarie.SetError(textBoxSalaireBrut, "Le salaire brut n'est pas valide");
            }
            else
            {
                epSalarie.SetError(textBoxSalaireBrut, string.Empty);
            }
            //---------------------------------------------------------------------------------
            decimal tauxcsConverti;

            if ((!decimal.TryParse(textBoxTauxCS.Text, out tauxcsConverti)) || decimal.Parse(textBoxTauxCS.Text) < 0 || decimal.Parse(textBoxTauxCS.Text) > 0.6m)
            {
                valid = false;
                epSalarie.SetError(textBoxTauxCS, "Le taux CS n'est pas valide");
            }
            else
            {
                epSalarie.SetError(textBoxTauxCS, string.Empty);
            }
            //--------------------------------------------------------------------------
            decimal chiffreaffaireConverti;

            if ((!decimal.TryParse(textBoxChiffreAffaire.Text, out chiffreaffaireConverti)) || decimal.Parse(textBoxChiffreAffaire.Text) < 0 || decimal.Parse(textBoxChiffreAffaire.Text) > 0.6m)

            {
                valid = false;
                epSalarie.SetError(textBoxChiffreAffaire, "Le chiffre d'affaire n'est pas valide");
            }
            else
            {
                epSalarie.SetError(textBoxChiffreAffaire, string.Empty);
            }
            //     //---- --------------------------------------------------------------------

            decimal commissionConverti;

            if ((!decimal.TryParse(textBoxCommission.Text, out commissionConverti)) || decimal.Parse(textBoxCommission.Text) < 0 || decimal.Parse(textBoxCommission.Text) > 0.6m)
            {
                if ((textBoxCommission.Text) == null || int.Parse(textBoxCommission.Text) < 0)
                {
                    valid = false;
                    epSalarie.SetError(textBoxCommission, "Le taux de Commission n'est pas valide");
                }
                else
                {
                    epSalarie.SetError(textBoxCommission, string.Empty);
                }
            }



            return(valid);
        }
Esempio n. 12
0
        public void AjouterSalaries()
        {
            if (!(checkBoxCommercial.Checked))
            {
                Salarie salarie = new Salarie();
                if (Salarie.IsNomPrenomValide(textBoxNom.Text))
                {
                    salarie.Nom = textBoxNom.Text;
                    erreurCb.SetError(textBoxNom, "");
                }
                else
                {
                    erreurCb.SetError(textBoxNom, "Nom non valide");
                }
                if (Salarie.IsNomPrenomValide(textBoxPrenom.Text))
                {
                    salarie.Prenom = textBoxPrenom.Text;
                    erreurCb.SetError(textBoxPrenom, "");
                }
                else
                {
                    erreurCb.SetError(textBoxPrenom, "Prenom non valide");
                }


                bool ConvertionDate = DateTime.TryParse(textBoxDateDeNaissance.Text, out DateTime DateNaissanceConvertie);
                if (ConvertionDate == true && Salarie.IsDateNaissanceValide(DateNaissanceConvertie))
                {
                    salarie.DateNaissance = DateNaissanceConvertie;
                    erreurCb.SetError(textBoxDateDeNaissance, "");
                }
                else
                {
                    erreurCb.SetError(textBoxDateDeNaissance, "Date de naissance non valide");
                }
                if (Salarie.IsMatriculeValide(textBoxMatricule.Text))
                {
                    salarie.Matricule = textBoxMatricule.Text;
                    erreurCb.SetError(textBoxNom, "");
                }

                bool ConvertionSalaire = decimal.TryParse(textBoxSalaireBrut.Text, out decimal SalaireBrutConverti);
                if (ConvertionSalaire == true)
                {
                    salarie.SalaireBrut = SalaireBrutConverti;
                    erreurCb.SetError(textBoxSalaireBrut, "");
                }
                else
                {
                    erreurCb.SetError(textBoxSalaireBrut, "Format Salaire non valide");
                }
                bool ConvertionTauxCS = decimal.TryParse(textBoxTauxCS.Text, out decimal TauxCSConverti);
                if (ConvertionTauxCS == true && Salarie.IsTauxCSValid(TauxCSConverti))
                {
                    salarie.TauxCS = TauxCSConverti;
                    erreurCb.SetError(textBoxTauxCS, "");
                }
                else
                {
                    erreurCb.SetError(textBoxTauxCS, "TauxCS non valide");
                }

                if (!VerifValiditeSalarie())
                {
                    MessageBox.Show("Certains champs ne sont pas valides", "Erreur", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
                }
                else
                {
                    MessageBox.Show("Salarié crée avec succée", "Ajout", MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
                }

                salaries.Add(salarie);
                cbChoixSalarie.Items.Add(salarie.Matricule);
                salaries.Save(MonApplication.DispositifSauvegarde, Properties.Settings.Default.AppData);
            }
            else if (checkBoxCommercial.Checked)
            {
                Commercial commercial = new Commercial();


                textBoxChiffreAffaire.ReadOnly = false;
                textBoxCommission.ReadOnly     = false;
                bool converstionCA = decimal.TryParse(textBoxChiffreAffaire.Text, out decimal ChiffreAfConverti);
                if (!converstionCA)
                {
                    MessageBox.Show("Entrer un decimal", "Message d'erreur", MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
                }
                commercial.ChiffreAffaire = ChiffreAfConverti;
                bool convertionCom = decimal.TryParse(textBoxCommission.Text, out decimal ComConvertie);
                if (!convertionCom)
                {
                    MessageBox.Show("Entrer un decimal entre 0 et 0.6", "Message d'erreur", MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
                }
                commercial.Commission = ComConvertie;

                if (Salarie.IsNomPrenomValide(textBoxNom.Text))
                {
                    commercial.Nom = textBoxNom.Text;
                    erreurCb.SetError(textBoxNom, "");
                }
                else
                {
                    erreurCb.SetError(textBoxNom, "Nom non valide");
                }
                if (Salarie.IsNomPrenomValide(textBoxPrenom.Text))
                {
                    commercial.Prenom = textBoxPrenom.Text;
                    erreurCb.SetError(textBoxPrenom, "");
                }
                else
                {
                    erreurCb.SetError(textBoxPrenom, "Prenom non valide");
                }


                bool ConvertionDateCom = DateTime.TryParse(textBoxDateDeNaissance.Text, out DateTime DateNaissanceConvertieCom);
                if (ConvertionDateCom == true && Salarie.IsDateNaissanceValide(DateNaissanceConvertieCom))
                {
                    commercial.DateNaissance = DateNaissanceConvertieCom;
                    erreurCb.SetError(textBoxDateDeNaissance, "");
                }
                else
                {
                    erreurCb.SetError(textBoxDateDeNaissance, "Date de naissance non valide");
                }
                if (Salarie.IsMatriculeValide(textBoxMatricule.Text))
                {
                    commercial.Matricule = textBoxMatricule.Text;
                    erreurCb.SetError(textBoxNom, "");
                }

                bool ConvertionSalaireCom = decimal.TryParse(textBoxSalaireBrut.Text, out decimal SalaireBrutConvertiCom);
                if (ConvertionSalaireCom == true)
                {
                    commercial.SalaireBrut = SalaireBrutConvertiCom;
                    erreurCb.SetError(textBoxSalaireBrut, "");
                }
                else
                {
                    erreurCb.SetError(textBoxSalaireBrut, "Format Salaire non valide");
                }
                bool ConvertionTauxCSCom = decimal.TryParse(textBoxTauxCS.Text, out decimal TauxCSConvertiCom);
                if (ConvertionTauxCSCom == true && Salarie.IsTauxCSValid(TauxCSConvertiCom))
                {
                    commercial.TauxCS = TauxCSConvertiCom;
                    erreurCb.SetError(textBoxTauxCS, "");
                }
                else
                {
                    erreurCb.SetError(textBoxTauxCS, "TauxCS non valide");
                }
                salaries.Add(commercial);
                cbChoixSalarie.Items.Add(commercial.Matricule);
                salaries.Save(MonApplication.DispositifSauvegarde, Properties.Settings.Default.AppData);
                checkBoxCommercial.Checked = false;
                textBoxChiffreAffaire.Clear();
                textBoxCommission.Clear();
            }

            textBoxDateDeNaissance.Clear();
            textBoxTauxCS.Clear();
            textBoxMatricule.Clear();
            textBoxNom.Clear();
            textBoxPrenom.Clear();
            textBoxSalaireBrut.Clear();
        }
Esempio n. 13
0
        private bool IsValidChamps()
        {
            bool valid = true;

            if (!Salarie.IsMatriculeValide(txtMatricule.Text))
            {
                valid = false;
                epSalarie.SetError(txtMatricule, "Le matricule n'est pas valide");
            }
            else
            {
                epSalarie.SetError(txtMatricule, string.Empty);
            }

            if (!Salarie.IsNomPrenomValide(txtNom.Text))
            {
                valid = false;
                epSalarie.SetError(txtNom, "Le nom n'est pas valide");
            }
            else
            {
                epSalarie.SetError(txtNom, string.Empty);
            }

            if (!Salarie.IsNomPrenomValide(txtPrenom.Text))
            {
                valid = false;
                epSalarie.SetError(txtPrenom, "Le prénom n'est pas valide");
            }
            else
            {
                epSalarie.SetError(txtPrenom, string.Empty);
            }

            DateTime sertArien1;

            if (!DateTime.TryParse(txtBDay.Text, out sertArien1))
            {
                valid = false;
                epSalarie.SetError(txtBDay, "La date de naissance n'est pas valide");
            }
            else
            {
                epSalarie.SetError(txtBDay, string.Empty);
            }

            decimal sertArien2;

            if (!decimal.TryParse(txtSalaireBrut.Text, out sertArien2))
            {
                valid = false;
                epSalarie.SetError(txtSalaireBrut, "Le salaire brut n'est pas valide");
            }
            else
            {
                epSalarie.SetError(txtSalaireBrut, string.Empty);
            }

            if (!decimal.TryParse(txtTauxCS.Text.Replace('.', ','), out sertArien2))
            {
                valid = false;
                epSalarie.SetError(txtTauxCS, "Le taux CA n'est pas valide");
            }
            else
            {
                epSalarie.SetError(txtTauxCS, string.Empty);
            }

            if (chkCommercial.Checked)
            {
                if (!decimal.TryParse(txtCA.Text, out sertArien2))
                {
                    valid = false;
                    epSalarie.SetError(txtCA, "Le CA n'est pas valide");
                }
                else
                {
                    epSalarie.SetError(txtCA, string.Empty);
                }
                if (!decimal.TryParse(txtComm.Text, out sertArien2))
                {
                    valid = false;
                    epSalarie.SetError(txtComm, "La commision n'est pas valide");
                }
                else
                {
                    epSalarie.SetError(txtComm, string.Empty);
                }
            }
            return(valid);
        }