Exemple #1
0
        /// <summary>
        /// Méthode permettant de réaliser la modification d'un membre privé par le biais du set d'une propriété publique correspondant à un champ particulier de l'entité
        /// </summary>
        /// <typeparam name="T">Type de données du membre privé (et donc de cette propriété publique)</typeparam>
        /// <typeparam name="U">Type de données de la propriété publique exposant la valeur de ce membre privé</typeparam>
        /// <param name="ChampConcerne">Valeur enumérée représentant le champ géré par ce membre privé et cette propriété publique</param>
        /// <param name="MembrePrive">Membre privé à modifier</param>
        /// <param name="NouvelleValeur">Nouvelle valeur à attribuer à ce membre privé</param>
        /// <param name="TransformationMembreVersPropriete">Méthode optionelle permettant de réaliser la transformation d'une valeur type "membre privé" en une valeur type "propriété publique"</param>
        /// <returns>Vrai si la modification a été acceptée et réalisée, sinon faux</returns>
        protected bool ModifierChamp <T, U>(TChamp ChampConcerne, ref T MembrePrive, T NouvelleValeur, Func <T, U> TransformationMembreVersPropriete = null)
        {
            bool ModificationAcceptee = true;

            if (MethodeAttacheeA_AvantChangement)
            {
                AccumulateurErreur AccumulateurErreur = new AccumulateurErreur();
                if (TransformationMembreVersPropriete != null)
                {
                    Declencher_AvantChangement(this as TEntite, ChampConcerne, TransformationMembreVersPropriete(MembrePrive), TransformationMembreVersPropriete(NouvelleValeur), AccumulateurErreur);
                }
                else
                {
                    Declencher_AvantChangement(this as TEntite, ChampConcerne, MembrePrive, NouvelleValeur, AccumulateurErreur);
                }
                ModificationAcceptee = AccumulateurErreur.Accepte;
                if (!ModificationAcceptee)
                {
                    Declencher_SurErreur(this as TEntite, ChampConcerne, AccumulateurErreur.MessageErreur);
                }
            }
            if (ModificationAcceptee)
            {
                if (MethodeAttacheeA_ApresChangement)
                {
                    T ValeurPrecedente = MembrePrive;
                    MembrePrive = NouvelleValeur;
                    if (TransformationMembreVersPropriete != null)
                    {
                        Declencher_ApresChangement(this as TEntite, ChampConcerne, TransformationMembreVersPropriete(ValeurPrecedente), TransformationMembreVersPropriete(MembrePrive));
                    }
                    else
                    {
                        Declencher_ApresChangement(this as TEntite, ChampConcerne, ValeurPrecedente, MembrePrive);
                    }
                }
                else
                {
                    MembrePrive = NouvelleValeur;
                }
                ChampEstValide(ChampConcerne, true);
                return(true);
            }
            else
            {
                ChampEstValide(ChampConcerne, false);
                return(false);
            }
        }
Exemple #2
0
 /// <summary>
 /// Méthode pouvant être attachée à l'événement AvantChangement
 /// </summary>
 /// <param name="Entite">Entité concernée par le changement</param>
 /// <param name="Champ">Champ concerné par le changement</param>
 /// <param name="ValeurActuelle">Valeur actuelle du champ concerné par le changement</param>
 /// <param name="NouvelleValeur">Nouvelle valeur à affecter au champ concerné par le changement</param>
 /// <param name="AccumulateurErreur">Accumulateur de notification d'erreur servant à refuser le changement</param>
 protected void Declencher_AvantChangement(TEntite Entite, TChamp Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
 {
     if (AvantChangement != null)
     {
         AvantChangement(Entite, Champ, ValeurActuelle, NouvelleValeur, AccumulateurErreur);
     }
 }
        /// <summary>
        /// Methode permettant de vérifier si les champs sont bien remplis avant la modification du véhicule
        /// </summary>
        private void VehiculeVenteEnEdition_AvantChangement(VehiculeVente Entite, VehiculeVente.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
        {
            switch (Champ)
            {
            case VehiculeVente.Champs.DateArrivee:
                if (DateTime.Parse(NouvelleValeur.ToString()) < Entite.DateCommande)
                {
                    AccumulateurErreur.NotifierErreur(string.Format("La date de réception ne peut pas être inférieure à la date de commande"));
                }
                break;

            case VehiculeVente.Champs.NumeroChassis:     // Dans ce cas particulier, le véhicule étant un nouveau véhicule, l'unicité de ce numéro doit être respecté
                VehiculeVente UniciteNumChassis = Program.GMBD.EnumererVehiculeVente(new PDSGBD.MyDB.CodeSql("numero_chassis"), null, new PDSGBD.MyDB.CodeSql("WHERE numero_chassis = {0}", NouvelleValeur), null).FirstOrDefault();
                if (string.IsNullOrWhiteSpace(NouvelleValeur.ToString()))
                {
                    AccumulateurErreur.NotifierErreur("Le numéro de châssis doit être indiqué afin de finaliser la vente");
                }
                else if (UniciteNumChassis != null)
                {
                    AccumulateurErreur.NotifierErreur("Ce numéro de châssis existe déjà pour un autre véhicule");
                }
                break;

            case VehiculeVente.Champs.AnneeConstruction:
                int AnneeTemp = 0;
                if (int.TryParse(NouvelleValeur.ToString(), out AnneeTemp) && (AnneeTemp < 1) || (AnneeTemp > 9999))
                {
                    AccumulateurErreur.NotifierErreur(string.Format("L'année de construction doit comprendre 4 chiffres"));
                }
                break;
            }
        }
        /// <summary>
        /// Methode permettant de vérifier si les champs sont bien remplis avant la modification de la facture
        /// </summary>
        private void FactureEnEdition_AvantChangement(FactureVente Entite, FactureVente.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
        {
            switch (Champ)
            {
            case FactureVente.Champs.RemiseSurReprise:
                int Remise = 0;
                if ((listeDeroulanteClientVehicule1.ClientVehiculeSelectionne != null) && (NouvelleValeur.ToString() != ""))
                {
                    if (int.TryParse(textBoxRemise.Text, out Remise))
                    {
                        if ((listeDeroulanteClientVehicule1.ClientVehiculeSelectionne != null) && (int.Parse(textBoxRemise.Text) < 0) || (int.Parse(textBoxRemise.Text) > listeDeroulanteFactureVente1.FactureVenteSelectionne.VehiculeVente.PrixTotal))
                        {
                            AccumulateurErreur.NotifierErreur(string.Format("La remise doit être comprise entre 1 € et {0} €", listeDeroulanteFactureVente1.FactureVenteSelectionne.VehiculeVente.PrixTotal));
                        }
                    }
                    else
                    {
                        AccumulateurErreur.NotifierErreur(string.Format("La remise doit être comprise entre 1 € et {0} €", listeDeroulanteFactureVente1.FactureVenteSelectionne.VehiculeVente.PrixTotal));
                    }
                }
                break;

            default:
                break;
            }
        }
        private void NouvelEmploye_AvantChangement(Employe Entite, Employe.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
        {
            switch (Champ)
            {
            case Employe.Champs.MotDePasse:
            {
                if (TextBoxMdp.Text != TextBoxConfMdp.Text)
                {
                    AccumulateurErreur.NotifierErreur("Les mots de passe ne correspondent pas");
                }
            }
            break;

            default:
                break;
            }
        }
 private void ModifierPack_AvantChangement(PackOptionPackVehicule Entite, PackOptionPackVehicule.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
 {
     AccumulateurErreur.ClearAccumulateur();
     switch (Champ)
     {
     case PackOptionPackVehicule.Champs.NomPack:
     {
         PackOptionPackVehicule PackExiste = Program.GMBD.EnumererPackOptionVehicule(new PDSGBD.MyDB.CodeSql("nom_pack"), null, new PDSGBD.MyDB.CodeSql("WHERE nom_pack = {0} AND id_pack_option_pack_vehicule != {1} AND disponible = 1", NouvelleValeur, listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne.Id), null).FirstOrDefault();
         if (PackExiste != null)
         {
             AccumulateurErreur.NotifierErreur("Ce pack existe déjà, veuillez rajouter cette option au pack existant ou recréer un nouveau pack");
         }
         break;
     }
     }
 }
 private void NouvelleOptionLiee_AvantChangement(PackOption Entite, PackOption.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
 {
     switch (Champ)
     {
     case PackOption.Champs.OptionVehicule:
     {
         PackOption OptionExistePourCePack = Program.GMBD.EnumererPackOption(null, null, new PDSGBD.MyDB.CodeSql("where fk_id_option_vehicule = {0} AND fk_id_popv = {1}", ficheOptionsPackRecherche.OptionsSelectionnee.Id, listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne.Id), null).FirstOrDefault();
         if (OptionExistePourCePack != null)
         {
             AccumulateurErreur.NotifierErreur("Cette option est déjà existante dans ce pack");
         }
         break;
     }
     }
 }
        /// <summary>
        /// Methode permettant de vérifier si l'immatriculations et le numero de châssis existe déjà avant le changement de celle ci dans la base de données
        /// </summary>
        /// <param name="Entite"></param>
        /// <param name="Champ"></param>
        /// <param name="ValeurActuelle"></param>
        /// <param name="NouvelleValeur"></param>
        /// <param name="AccumulateurErreur"></param>
        private void ClientVehiculeEnAjout_AvantChangement(ClientVehicule Entite, ClientVehicule.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
        {
            switch (Champ)
            {
            case ClientVehicule.Champs.Immatriculation:
                ClientVehicule ImmatriculationExiste = Program.GMBD.EnumererClientVehicule(null, null, new PDSGBD.MyDB.CodeSql("WHERE immatriculation = {0} AND vehicule_actif = 1", NouvelleValeur), null).FirstOrDefault();
                if (ImmatriculationExiste != null)
                {
                    ValidationProvider.Clear();
                    AccumulateurErreur.NotifierErreur("Cette immatriculation existe déjà pour un autre véhicule!");
                }
                if (textBoxImmatriculation.Text.Length < 1)
                {
                    ValidationProvider.Clear();
                    AccumulateurErreur.NotifierErreur("L'immatriculation doit être indiquée");
                }
                break;

            case ClientVehicule.Champs.NumeroChassis:
            {
                ClientVehicule NumeroChassisExiste = Program.GMBD.EnumererClientVehicule(null, null, new PDSGBD.MyDB.CodeSql("WHERE numero_chassis = {0} AND vehicule_actif = 1", NouvelleValeur), null).FirstOrDefault();
                if (NumeroChassisExiste != null)
                {
                    ValidationProvider.Clear();
                    AccumulateurErreur.NotifierErreur("Ce numéro de châssis existe déjà pour un autre véhicule!");
                }
                break;
            }
            }
        }
Exemple #9
0
        private void NouvelEntretien_AvantChangement(Entretien Entite, Entretien.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
        {
            switch (Champ)
            {
            case Entretien.Champs.TypeEntretien:
                Entretien EntretienExiste = Program.GMBD.EnumererEntretien(null, null, new PDSGBD.MyDB.CodeSql("WHERE type_entretien = {0} AND disponible = 1", textBoxEntretien.Text), null).FirstOrDefault();
                if (EntretienExiste != null)
                {
                    AccumulateurErreur.NotifierErreur("Un entretien portant ce nom existe déjà");
                }
                break;

            default:
                break;
            }
        }
        private void EmployeAModifier_AvantChangement(Employe Entite, Employe.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
        {
            switch (Champ)
            {
            case Employe.Champs.MotDePasse:
            {
                if (TextBoxMdp.Text != TextBoxConfMdp.Text)
                {
                    AccumulateurErreur.NotifierErreur("Les mots de passe ne correspondent pas");
                }
            }
            break;

            case Employe.Champs.Email:
            {
                Employe EmailExiste = Program.GMBD.EnumererEmploye(null, null, new PDSGBD.MyDB.CodeSql("WHERE email = {0} AND id_employe != {1}", NouvelleValeur, EmployeSelectionne.Id), null).FirstOrDefault();
                if (EmailExiste != null)
                {
                    AccumulateurErreur.NotifierErreur("L'email existe déjà, veuillez en choisir une autre");
                }
            }
            break;

            default:
                break;
            }
        }
 private void NouvelleValeurCaracteristique_AvantChangement(VehiculeCaracteristique Entite, VehiculeCaracteristique.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
 {
     switch (Champ)
     {
     case VehiculeCaracteristique.Champs.Caracteristique:
         VehiculeCaracteristique CaracteristiqueExiste = Program.GMBD.EnumererVehiculeCaracteristique(null, null, new PDSGBD.MyDB.CodeSql("WHERE fk_id_caracteristique = {0} AND fk_id_vehicule = {1}", listeDeroulanteCaracteristique1.CaracteristiqueSelectionne.Id, listeDeroulanteVehicule1.VehiculeSelectionne.Id), null).FirstOrDefault();
         if (CaracteristiqueExiste != null)
         {
             errorProvider.Clear();
             ValidationProvider.Clear();
             AccumulateurErreur.NotifierErreur("Cette caractéristique existe déjà pour ce véhicule");
         }
         break;
     }
 }
 private void NouvelleCaracteristique_AvantChangement(Caracteristique Entite, Caracteristique.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
 {
     switch (Champ)
     {
     case Caracteristique.Champs.Type:
         if (listeDeroulanteTypeVehicule1.TypeVehiculeSelectionne == null)
         {
             ValidationProvider.Clear();
             AccumulateurErreur.NotifierErreur("Veuillez choisir un type pour la caractéristique");
         }
         break;
     }
 }
 /// <summary>
 /// Se produit avant la modification en base de données
 /// </summary>
 private void VehiculeAModifier_AvantChangement(Vehicule Entite, Vehicule.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
 {
     switch (Champ)
     {
     case Vehicule.Champs.Modele:
         Vehicule ModeleExiste = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type_vehicule ON vehicule.fk_id_type = type.id_type"), new PDSGBD.MyDB.CodeSql("WHERE modele = {0} AND id_vehicule != {1} AND type = {2} AND disponible = 1", NouvelleValeur, Entite.Id, (EstMoto) ? "Moto" : "Voiture"), null).FirstOrDefault();
         if (ModeleExiste != null)
         {
             ValidationProvider.Clear();
             AccumulateurErreur.NotifierErreur("Ce modèle existe déjà");
         }
         break;
     }
 }
 /// <summary>
 /// Se produit avant le changement dans la base de données
 /// </summary>
 private void NouveauVehicule_AvantChangement(Vehicule Entite, Vehicule.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
 {
     switch (Champ)
     {
     case Vehicule.Champs.Modele:
         Vehicule ModeleExiste = Program.GMBD.EnumererVehicule(null, null, new PDSGBD.MyDB.CodeSql("WHERE modele = {0} AND disponible = 1", NouvelleValeur)
                                                               , null).FirstOrDefault();
         if (ModeleExiste != null)
         {
             AccumulateurErreur.NotifierErreur("Ce nom de modèle existe déjà");
         }
         break;
     }
 }
 private void NouvelleOption_AvantChangement(OptionVehicule Entite, OptionVehicule.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
 {
     AccumulateurErreur.ClearAccumulateur();
     switch (Champ)
     {
     case OptionVehicule.Champs.NomOption:
     {
         OptionVehicule OptionExiste = Program.GMBD.EnumererOptionVehicule(new PDSGBD.MyDB.CodeSql("nom_option"), null, new PDSGBD.MyDB.CodeSql("where nom_option = {0} AND disponible = 1", NouvelleValeur), null).FirstOrDefault();
         if (OptionExiste != null)
         {
             AccumulateurErreur.NotifierErreur("Cette option existe déjà, veuillez revérifier par une recherche de l'enregistrement désiré");
         }
         break;
     }
     }
 }
Exemple #16
0
        /// <summary>
        /// Methode permettant de vérifier si le client existe avant le changement de celle ci dans la base de données
        /// </summary>
        /// <param name="Entite"></param>
        /// <param name="Champ"></param>
        /// <param name="ValeurActuelle"></param>
        /// <param name="NouvelleValeur"></param>
        /// <param name="AccumulateurErreur"></param>
        private void ClientEnEdition_AvantChangement(Client Entite, Client.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
        {
            switch (Champ)
            {
            case Client.Champs.NumeroTelephone:
                long NumTel = 0;
                if (!long.TryParse(textBoxNumTel.Text, out NumTel))
                {
                    AccumulateurErreur.NotifierErreur("Le numéro de téléphone doit être de type numérique ! ");
                }
                break;

            case Client.Champs.Email:
            {
                Client ClientExiste = Program.GMBD.EnumererClient(null, null, new PDSGBD.MyDB.CodeSql("WHERE client.email_client = {0} AND id_client != {1}", NouvelleValeur, Entite.Id), null).FirstOrDefault();
                if (ClientExiste != null)
                {
                    ValidationProvider.Clear();
                    AccumulateurErreur.NotifierErreur("Un autre client a déjà cet email !");
                }
                break;
            }
            }
        }
        /// <summary>
        /// Methode permettant de vérifier si l'immatriculations et le numero de châssis existe déjà avant le changement de celle ci dans la base de données
        /// </summary>
        /// <param name="Entite"></param>
        /// <param name="Champ"></param>
        /// <param name="ValeurActuelle"></param>
        /// <param name="NouvelleValeur"></param>
        /// <param name="AccumulateurErreur"></param>
        private void ClientVehiculeEnEdition_AvantChangement(ClientVehicule Entite, ClientVehicule.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
        {
            switch (Champ)
            {
            case ClientVehicule.Champs.Immatriculation:
                ClientVehicule ImmatriculationExiste = Program.GMBD.EnumererClientVehicule(null, null, new PDSGBD.MyDB.CodeSql("WHERE immatriculation = {0} AND fk_id_client != {1} AND vehicule_actif = 1", NouvelleValeur, Entite.Client.Id), null).FirstOrDefault();
                if (NouvelleValeur.ToString().Length < 1)
                {
                    AccumulateurErreur.NotifierErreur("Le numéro d'immatriculation doit comprendre au minimum un caractère");
                    break;
                }
                if (ImmatriculationExiste != null)
                {
                    ValidationProvider.Clear();
                    AccumulateurErreur.NotifierErreur("Cette immatriculation existe déjà pour un autre véhicule!");
                }
                break;

            case ClientVehicule.Champs.NumeroChassis:
            {
                ClientVehicule NumeroChassisExiste = Program.GMBD.EnumererClientVehicule(null, null, new PDSGBD.MyDB.CodeSql("WHERE numero_chassis = {0} AND fk_id_client != {1} AND vehicule_actif = 1", NouvelleValeur, Entite.Client.Id), null).FirstOrDefault();
                if (NouvelleValeur.ToString().Length < 1)
                {
                    AccumulateurErreur.NotifierErreur("Le numéro de châssis doit comprendre au minimum un caractère");
                    break;
                }
                if (NumeroChassisExiste != null)
                {
                    ValidationProvider.Clear();
                    AccumulateurErreur.NotifierErreur("Ce numéro de châssis existe déjà pour un autre véhicule!");
                }
                break;
            }
            }
        }